1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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 "hda_beep.h"
34#include <sound/hda_hwdep.h>
35
36
37
38
39
40struct hda_vendor_id {
41 unsigned int id;
42 const char *name;
43};
44
45
46static struct hda_vendor_id hda_vendor_ids[] = {
47 { 0x1002, "ATI" },
48 { 0x1013, "Cirrus Logic" },
49 { 0x1057, "Motorola" },
50 { 0x1095, "Silicon Image" },
51 { 0x10de, "Nvidia" },
52 { 0x10ec, "Realtek" },
53 { 0x1102, "Creative" },
54 { 0x1106, "VIA" },
55 { 0x111d, "IDT" },
56 { 0x11c1, "LSI" },
57 { 0x11d4, "Analog Devices" },
58 { 0x13f6, "C-Media" },
59 { 0x14f1, "Conexant" },
60 { 0x17e8, "Chrontel" },
61 { 0x1854, "LG" },
62 { 0x1aec, "Wolfson Microelectronics" },
63 { 0x434d, "C-Media" },
64 { 0x8086, "Intel" },
65 { 0x8384, "SigmaTel" },
66 {}
67};
68
69static DEFINE_MUTEX(preset_mutex);
70static LIST_HEAD(hda_preset_tables);
71
72int snd_hda_add_codec_preset(struct hda_codec_preset_list *preset)
73{
74 mutex_lock(&preset_mutex);
75 list_add_tail(&preset->list, &hda_preset_tables);
76 mutex_unlock(&preset_mutex);
77 return 0;
78}
79EXPORT_SYMBOL_HDA(snd_hda_add_codec_preset);
80
81int snd_hda_delete_codec_preset(struct hda_codec_preset_list *preset)
82{
83 mutex_lock(&preset_mutex);
84 list_del(&preset->list);
85 mutex_unlock(&preset_mutex);
86 return 0;
87}
88EXPORT_SYMBOL_HDA(snd_hda_delete_codec_preset);
89
90#ifdef CONFIG_SND_HDA_POWER_SAVE
91static void hda_power_work(struct work_struct *work);
92static void hda_keep_power_on(struct hda_codec *codec);
93#else
94static inline void hda_keep_power_on(struct hda_codec *codec) {}
95#endif
96
97
98
99
100
101
102
103
104const char *snd_hda_get_jack_location(u32 cfg)
105{
106 static char *bases[7] = {
107 "N/A", "Rear", "Front", "Left", "Right", "Top", "Bottom",
108 };
109 static unsigned char specials_idx[] = {
110 0x07, 0x08,
111 0x17, 0x18, 0x19,
112 0x37, 0x38
113 };
114 static char *specials[] = {
115 "Rear Panel", "Drive Bar",
116 "Riser", "HDMI", "ATAPI",
117 "Mobile-In", "Mobile-Out"
118 };
119 int i;
120 cfg = (cfg & AC_DEFCFG_LOCATION) >> AC_DEFCFG_LOCATION_SHIFT;
121 if ((cfg & 0x0f) < 7)
122 return bases[cfg & 0x0f];
123 for (i = 0; i < ARRAY_SIZE(specials_idx); i++) {
124 if (cfg == specials_idx[i])
125 return specials[i];
126 }
127 return "UNKNOWN";
128}
129EXPORT_SYMBOL_HDA(snd_hda_get_jack_location);
130
131
132
133
134
135
136
137
138const char *snd_hda_get_jack_connectivity(u32 cfg)
139{
140 static char *jack_locations[4] = { "Ext", "Int", "Sep", "Oth" };
141
142 return jack_locations[(cfg >> (AC_DEFCFG_LOCATION_SHIFT + 4)) & 3];
143}
144EXPORT_SYMBOL_HDA(snd_hda_get_jack_connectivity);
145
146
147
148
149
150
151
152
153const char *snd_hda_get_jack_type(u32 cfg)
154{
155 static char *jack_types[16] = {
156 "Line Out", "Speaker", "HP Out", "CD",
157 "SPDIF Out", "Digital Out", "Modem Line", "Modem Hand",
158 "Line In", "Aux", "Mic", "Telephony",
159 "SPDIF In", "Digitial In", "Reserved", "Other"
160 };
161
162 return jack_types[(cfg & AC_DEFCFG_DEVICE)
163 >> AC_DEFCFG_DEVICE_SHIFT];
164}
165EXPORT_SYMBOL_HDA(snd_hda_get_jack_type);
166
167
168
169
170static inline unsigned int
171make_codec_cmd(struct hda_codec *codec, hda_nid_t nid, int direct,
172 unsigned int verb, unsigned int parm)
173{
174 u32 val;
175
176 if ((codec->addr & ~0xf) || (direct & ~1) || (nid & ~0x7f) ||
177 (verb & ~0xfff) || (parm & ~0xffff)) {
178 printk(KERN_ERR "hda-codec: out of range cmd %x:%x:%x:%x:%x\n",
179 codec->addr, direct, nid, verb, parm);
180 return ~0;
181 }
182
183 val = (u32)codec->addr << 28;
184 val |= (u32)direct << 27;
185 val |= (u32)nid << 20;
186 val |= verb << 8;
187 val |= parm;
188 return val;
189}
190
191
192
193
194static int codec_exec_verb(struct hda_codec *codec, unsigned int cmd,
195 unsigned int *res)
196{
197 struct hda_bus *bus = codec->bus;
198 int err;
199
200 if (cmd == ~0)
201 return -1;
202
203 if (res)
204 *res = -1;
205 again:
206 snd_hda_power_up(codec);
207 mutex_lock(&bus->cmd_mutex);
208 err = bus->ops.command(bus, cmd);
209 if (!err && res)
210 *res = bus->ops.get_response(bus, codec->addr);
211 mutex_unlock(&bus->cmd_mutex);
212 snd_hda_power_down(codec);
213 if (res && *res == -1 && bus->rirb_error) {
214 if (bus->response_reset) {
215 snd_printd("hda_codec: resetting BUS due to "
216 "fatal communication error\n");
217 bus->ops.bus_reset(bus);
218 }
219 goto again;
220 }
221
222 if (!err)
223 bus->response_reset = 0;
224 return err;
225}
226
227
228
229
230
231
232
233
234
235
236
237
238
239unsigned int snd_hda_codec_read(struct hda_codec *codec, hda_nid_t nid,
240 int direct,
241 unsigned int verb, unsigned int parm)
242{
243 unsigned cmd = make_codec_cmd(codec, nid, direct, verb, parm);
244 unsigned int res;
245 codec_exec_verb(codec, cmd, &res);
246 return res;
247}
248EXPORT_SYMBOL_HDA(snd_hda_codec_read);
249
250
251
252
253
254
255
256
257
258
259
260
261
262int snd_hda_codec_write(struct hda_codec *codec, hda_nid_t nid, int direct,
263 unsigned int verb, unsigned int parm)
264{
265 unsigned int cmd = make_codec_cmd(codec, nid, direct, verb, parm);
266 unsigned int res;
267 return codec_exec_verb(codec, cmd,
268 codec->bus->sync_write ? &res : NULL);
269}
270EXPORT_SYMBOL_HDA(snd_hda_codec_write);
271
272
273
274
275
276
277
278
279
280void snd_hda_sequence_write(struct hda_codec *codec, const struct hda_verb *seq)
281{
282 for (; seq->nid; seq++)
283 snd_hda_codec_write(codec, seq->nid, 0, seq->verb, seq->param);
284}
285EXPORT_SYMBOL_HDA(snd_hda_sequence_write);
286
287
288
289
290
291
292
293
294
295
296int snd_hda_get_sub_nodes(struct hda_codec *codec, hda_nid_t nid,
297 hda_nid_t *start_id)
298{
299 unsigned int parm;
300
301 parm = snd_hda_param_read(codec, nid, AC_PAR_NODE_COUNT);
302 if (parm == -1)
303 return 0;
304 *start_id = (parm >> 16) & 0x7fff;
305 return (int)(parm & 0x7fff);
306}
307EXPORT_SYMBOL_HDA(snd_hda_get_sub_nodes);
308
309
310
311
312
313
314
315
316
317
318
319
320
321int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid,
322 hda_nid_t *conn_list, int max_conns)
323{
324 unsigned int parm;
325 int i, conn_len, conns;
326 unsigned int shift, num_elems, mask;
327 unsigned int wcaps;
328 hda_nid_t prev_nid;
329
330 if (snd_BUG_ON(!conn_list || max_conns <= 0))
331 return -EINVAL;
332
333 wcaps = get_wcaps(codec, nid);
334 if (!(wcaps & AC_WCAP_CONN_LIST) &&
335 get_wcaps_type(wcaps) != AC_WID_VOL_KNB) {
336 snd_printk(KERN_WARNING "hda_codec: "
337 "connection list not available for 0x%x\n", nid);
338 return -EINVAL;
339 }
340
341 parm = snd_hda_param_read(codec, nid, AC_PAR_CONNLIST_LEN);
342 if (parm & AC_CLIST_LONG) {
343
344 shift = 16;
345 num_elems = 2;
346 } else {
347
348 shift = 8;
349 num_elems = 4;
350 }
351 conn_len = parm & AC_CLIST_LENGTH;
352 mask = (1 << (shift-1)) - 1;
353
354 if (!conn_len)
355 return 0;
356
357 if (conn_len == 1) {
358
359 parm = snd_hda_codec_read(codec, nid, 0,
360 AC_VERB_GET_CONNECT_LIST, 0);
361 if (parm == -1 && codec->bus->rirb_error)
362 return -EIO;
363 conn_list[0] = parm & mask;
364 return 1;
365 }
366
367
368 conns = 0;
369 prev_nid = 0;
370 for (i = 0; i < conn_len; i++) {
371 int range_val;
372 hda_nid_t val, n;
373
374 if (i % num_elems == 0) {
375 parm = snd_hda_codec_read(codec, nid, 0,
376 AC_VERB_GET_CONNECT_LIST, i);
377 if (parm == -1 && codec->bus->rirb_error)
378 return -EIO;
379 }
380 range_val = !!(parm & (1 << (shift-1)));
381 val = parm & mask;
382 if (val == 0) {
383 snd_printk(KERN_WARNING "hda_codec: "
384 "invalid CONNECT_LIST verb %x[%i]:%x\n",
385 nid, i, parm);
386 return 0;
387 }
388 parm >>= shift;
389 if (range_val) {
390
391 if (!prev_nid || prev_nid >= val) {
392 snd_printk(KERN_WARNING "hda_codec: "
393 "invalid dep_range_val %x:%x\n",
394 prev_nid, val);
395 continue;
396 }
397 for (n = prev_nid + 1; n <= val; n++) {
398 if (conns >= max_conns) {
399 snd_printk(KERN_ERR "hda_codec: "
400 "Too many connections %d for NID 0x%x\n",
401 conns, nid);
402 return -EINVAL;
403 }
404 conn_list[conns++] = n;
405 }
406 } else {
407 if (conns >= max_conns) {
408 snd_printk(KERN_ERR "hda_codec: "
409 "Too many connections %d for NID 0x%x\n",
410 conns, nid);
411 return -EINVAL;
412 }
413 conn_list[conns++] = val;
414 }
415 prev_nid = val;
416 }
417 return conns;
418}
419EXPORT_SYMBOL_HDA(snd_hda_get_connections);
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434int snd_hda_queue_unsol_event(struct hda_bus *bus, u32 res, u32 res_ex)
435{
436 struct hda_bus_unsolicited *unsol;
437 unsigned int wp;
438
439 unsol = bus->unsol;
440 if (!unsol)
441 return 0;
442
443 wp = (unsol->wp + 1) % HDA_UNSOL_QUEUE_SIZE;
444 unsol->wp = wp;
445
446 wp <<= 1;
447 unsol->queue[wp] = res;
448 unsol->queue[wp + 1] = res_ex;
449
450 queue_work(bus->workq, &unsol->work);
451
452 return 0;
453}
454EXPORT_SYMBOL_HDA(snd_hda_queue_unsol_event);
455
456
457
458
459static void process_unsol_events(struct work_struct *work)
460{
461 struct hda_bus_unsolicited *unsol =
462 container_of(work, struct hda_bus_unsolicited, work);
463 struct hda_bus *bus = unsol->bus;
464 struct hda_codec *codec;
465 unsigned int rp, caddr, res;
466
467 while (unsol->rp != unsol->wp) {
468 rp = (unsol->rp + 1) % HDA_UNSOL_QUEUE_SIZE;
469 unsol->rp = rp;
470 rp <<= 1;
471 res = unsol->queue[rp];
472 caddr = unsol->queue[rp + 1];
473 if (!(caddr & (1 << 4)))
474 continue;
475 codec = bus->caddr_tbl[caddr & 0x0f];
476 if (codec && codec->patch_ops.unsol_event)
477 codec->patch_ops.unsol_event(codec, res);
478 }
479}
480
481
482
483
484static int init_unsol_queue(struct hda_bus *bus)
485{
486 struct hda_bus_unsolicited *unsol;
487
488 if (bus->unsol)
489 return 0;
490
491 unsol = kzalloc(sizeof(*unsol), GFP_KERNEL);
492 if (!unsol) {
493 snd_printk(KERN_ERR "hda_codec: "
494 "can't allocate unsolicited queue\n");
495 return -ENOMEM;
496 }
497 INIT_WORK(&unsol->work, process_unsol_events);
498 unsol->bus = bus;
499 bus->unsol = unsol;
500 return 0;
501}
502
503
504
505
506static void snd_hda_codec_free(struct hda_codec *codec);
507
508static int snd_hda_bus_free(struct hda_bus *bus)
509{
510 struct hda_codec *codec, *n;
511
512 if (!bus)
513 return 0;
514 if (bus->workq)
515 flush_workqueue(bus->workq);
516 if (bus->unsol)
517 kfree(bus->unsol);
518 list_for_each_entry_safe(codec, n, &bus->codec_list, list) {
519 snd_hda_codec_free(codec);
520 }
521 if (bus->ops.private_free)
522 bus->ops.private_free(bus);
523 if (bus->workq)
524 destroy_workqueue(bus->workq);
525 kfree(bus);
526 return 0;
527}
528
529static int snd_hda_bus_dev_free(struct snd_device *device)
530{
531 struct hda_bus *bus = device->device_data;
532 bus->shutdown = 1;
533 return snd_hda_bus_free(bus);
534}
535
536#ifdef CONFIG_SND_HDA_HWDEP
537static int snd_hda_bus_dev_register(struct snd_device *device)
538{
539 struct hda_bus *bus = device->device_data;
540 struct hda_codec *codec;
541 list_for_each_entry(codec, &bus->codec_list, list) {
542 snd_hda_hwdep_add_sysfs(codec);
543 snd_hda_hwdep_add_power_sysfs(codec);
544 }
545 return 0;
546}
547#else
548#define snd_hda_bus_dev_register NULL
549#endif
550
551
552
553
554
555
556
557
558
559int snd_hda_bus_new(struct snd_card *card,
560 const struct hda_bus_template *temp,
561 struct hda_bus **busp)
562{
563 struct hda_bus *bus;
564 int err;
565 static struct snd_device_ops dev_ops = {
566 .dev_register = snd_hda_bus_dev_register,
567 .dev_free = snd_hda_bus_dev_free,
568 };
569
570 if (snd_BUG_ON(!temp))
571 return -EINVAL;
572 if (snd_BUG_ON(!temp->ops.command || !temp->ops.get_response))
573 return -EINVAL;
574
575 if (busp)
576 *busp = NULL;
577
578 bus = kzalloc(sizeof(*bus), GFP_KERNEL);
579 if (bus == NULL) {
580 snd_printk(KERN_ERR "can't allocate struct hda_bus\n");
581 return -ENOMEM;
582 }
583
584 bus->card = card;
585 bus->private_data = temp->private_data;
586 bus->pci = temp->pci;
587 bus->modelname = temp->modelname;
588 bus->power_save = temp->power_save;
589 bus->ops = temp->ops;
590
591 mutex_init(&bus->cmd_mutex);
592 mutex_init(&bus->prepare_mutex);
593 INIT_LIST_HEAD(&bus->codec_list);
594
595 snprintf(bus->workq_name, sizeof(bus->workq_name),
596 "hd-audio%d", card->number);
597 bus->workq = create_singlethread_workqueue(bus->workq_name);
598 if (!bus->workq) {
599 snd_printk(KERN_ERR "cannot create workqueue %s\n",
600 bus->workq_name);
601 kfree(bus);
602 return -ENOMEM;
603 }
604
605 err = snd_device_new(card, SNDRV_DEV_BUS, bus, &dev_ops);
606 if (err < 0) {
607 snd_hda_bus_free(bus);
608 return err;
609 }
610 if (busp)
611 *busp = bus;
612 return 0;
613}
614EXPORT_SYMBOL_HDA(snd_hda_bus_new);
615
616#ifdef CONFIG_SND_HDA_GENERIC
617#define is_generic_config(codec) \
618 (codec->modelname && !strcmp(codec->modelname, "generic"))
619#else
620#define is_generic_config(codec) 0
621#endif
622
623#ifdef MODULE
624#define HDA_MODREQ_MAX_COUNT 2
625#else
626#define HDA_MODREQ_MAX_COUNT 0
627#endif
628
629
630
631
632static const struct hda_codec_preset *
633find_codec_preset(struct hda_codec *codec)
634{
635 struct hda_codec_preset_list *tbl;
636 const struct hda_codec_preset *preset;
637 int mod_requested = 0;
638
639 if (is_generic_config(codec))
640 return NULL;
641
642 again:
643 mutex_lock(&preset_mutex);
644 list_for_each_entry(tbl, &hda_preset_tables, list) {
645 if (!try_module_get(tbl->owner)) {
646 snd_printk(KERN_ERR "hda_codec: cannot module_get\n");
647 continue;
648 }
649 for (preset = tbl->preset; preset->id; preset++) {
650 u32 mask = preset->mask;
651 if (preset->afg && preset->afg != codec->afg)
652 continue;
653 if (preset->mfg && preset->mfg != codec->mfg)
654 continue;
655 if (!mask)
656 mask = ~0;
657 if (preset->id == (codec->vendor_id & mask) &&
658 (!preset->rev ||
659 preset->rev == codec->revision_id)) {
660 mutex_unlock(&preset_mutex);
661 codec->owner = tbl->owner;
662 return preset;
663 }
664 }
665 module_put(tbl->owner);
666 }
667 mutex_unlock(&preset_mutex);
668
669 if (mod_requested < HDA_MODREQ_MAX_COUNT) {
670 char name[32];
671 if (!mod_requested)
672 snprintf(name, sizeof(name), "snd-hda-codec-id:%08x",
673 codec->vendor_id);
674 else
675 snprintf(name, sizeof(name), "snd-hda-codec-id:%04x*",
676 (codec->vendor_id >> 16) & 0xffff);
677 request_module(name);
678 mod_requested++;
679 goto again;
680 }
681 return NULL;
682}
683
684
685
686
687static int get_codec_name(struct hda_codec *codec)
688{
689 const struct hda_vendor_id *c;
690 const char *vendor = NULL;
691 u16 vendor_id = codec->vendor_id >> 16;
692 char tmp[16];
693
694 if (codec->vendor_name)
695 goto get_chip_name;
696
697 for (c = hda_vendor_ids; c->id; c++) {
698 if (c->id == vendor_id) {
699 vendor = c->name;
700 break;
701 }
702 }
703 if (!vendor) {
704 sprintf(tmp, "Generic %04x", vendor_id);
705 vendor = tmp;
706 }
707 codec->vendor_name = kstrdup(vendor, GFP_KERNEL);
708 if (!codec->vendor_name)
709 return -ENOMEM;
710
711 get_chip_name:
712 if (codec->chip_name)
713 return 0;
714
715 if (codec->preset && codec->preset->name)
716 codec->chip_name = kstrdup(codec->preset->name, GFP_KERNEL);
717 else {
718 sprintf(tmp, "ID %x", codec->vendor_id & 0xffff);
719 codec->chip_name = kstrdup(tmp, GFP_KERNEL);
720 }
721 if (!codec->chip_name)
722 return -ENOMEM;
723 return 0;
724}
725
726
727
728
729static void setup_fg_nodes(struct hda_codec *codec)
730{
731 int i, total_nodes, function_id;
732 hda_nid_t nid;
733
734 total_nodes = snd_hda_get_sub_nodes(codec, AC_NODE_ROOT, &nid);
735 for (i = 0; i < total_nodes; i++, nid++) {
736 function_id = snd_hda_param_read(codec, nid,
737 AC_PAR_FUNCTION_TYPE);
738 switch (function_id & 0xff) {
739 case AC_GRP_AUDIO_FUNCTION:
740 codec->afg = nid;
741 codec->afg_function_id = function_id & 0xff;
742 codec->afg_unsol = (function_id >> 8) & 1;
743 break;
744 case AC_GRP_MODEM_FUNCTION:
745 codec->mfg = nid;
746 codec->mfg_function_id = function_id & 0xff;
747 codec->mfg_unsol = (function_id >> 8) & 1;
748 break;
749 default:
750 break;
751 }
752 }
753}
754
755
756
757
758static int read_widget_caps(struct hda_codec *codec, hda_nid_t fg_node)
759{
760 int i;
761 hda_nid_t nid;
762
763 codec->num_nodes = snd_hda_get_sub_nodes(codec, fg_node,
764 &codec->start_nid);
765 codec->wcaps = kmalloc(codec->num_nodes * 4, GFP_KERNEL);
766 if (!codec->wcaps)
767 return -ENOMEM;
768 nid = codec->start_nid;
769 for (i = 0; i < codec->num_nodes; i++, nid++)
770 codec->wcaps[i] = snd_hda_param_read(codec, nid,
771 AC_PAR_AUDIO_WIDGET_CAP);
772 return 0;
773}
774
775
776static int read_pin_defaults(struct hda_codec *codec)
777{
778 int i;
779 hda_nid_t nid = codec->start_nid;
780
781 for (i = 0; i < codec->num_nodes; i++, nid++) {
782 struct hda_pincfg *pin;
783 unsigned int wcaps = get_wcaps(codec, nid);
784 unsigned int wid_type = get_wcaps_type(wcaps);
785 if (wid_type != AC_WID_PIN)
786 continue;
787 pin = snd_array_new(&codec->init_pins);
788 if (!pin)
789 return -ENOMEM;
790 pin->nid = nid;
791 pin->cfg = snd_hda_codec_read(codec, nid, 0,
792 AC_VERB_GET_CONFIG_DEFAULT, 0);
793 pin->ctrl = snd_hda_codec_read(codec, nid, 0,
794 AC_VERB_GET_PIN_WIDGET_CONTROL,
795 0);
796 }
797 return 0;
798}
799
800
801static struct hda_pincfg *look_up_pincfg(struct hda_codec *codec,
802 struct snd_array *array,
803 hda_nid_t nid)
804{
805 int i;
806 for (i = 0; i < array->used; i++) {
807 struct hda_pincfg *pin = snd_array_elem(array, i);
808 if (pin->nid == nid)
809 return pin;
810 }
811 return NULL;
812}
813
814
815static void set_pincfg(struct hda_codec *codec, hda_nid_t nid,
816 unsigned int cfg)
817{
818 int i;
819 for (i = 0; i < 4; i++) {
820 snd_hda_codec_write(codec, nid, 0,
821 AC_VERB_SET_CONFIG_DEFAULT_BYTES_0 + i,
822 cfg & 0xff);
823 cfg >>= 8;
824 }
825}
826
827
828
829
830int snd_hda_add_pincfg(struct hda_codec *codec, struct snd_array *list,
831 hda_nid_t nid, unsigned int cfg)
832{
833 struct hda_pincfg *pin;
834 unsigned int oldcfg;
835
836 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
837 return -EINVAL;
838
839 oldcfg = snd_hda_codec_get_pincfg(codec, nid);
840 pin = look_up_pincfg(codec, list, nid);
841 if (!pin) {
842 pin = snd_array_new(list);
843 if (!pin)
844 return -ENOMEM;
845 pin->nid = nid;
846 }
847 pin->cfg = cfg;
848
849
850
851
852 cfg = snd_hda_codec_get_pincfg(codec, nid);
853 if (oldcfg != cfg)
854 set_pincfg(codec, nid, cfg);
855 return 0;
856}
857
858
859
860
861
862
863
864
865
866
867
868int snd_hda_codec_set_pincfg(struct hda_codec *codec,
869 hda_nid_t nid, unsigned int cfg)
870{
871 return snd_hda_add_pincfg(codec, &codec->driver_pins, nid, cfg);
872}
873EXPORT_SYMBOL_HDA(snd_hda_codec_set_pincfg);
874
875
876
877
878
879
880
881
882
883
884unsigned int snd_hda_codec_get_pincfg(struct hda_codec *codec, hda_nid_t nid)
885{
886 struct hda_pincfg *pin;
887
888#ifdef CONFIG_SND_HDA_HWDEP
889 pin = look_up_pincfg(codec, &codec->user_pins, nid);
890 if (pin)
891 return pin->cfg;
892#endif
893 pin = look_up_pincfg(codec, &codec->driver_pins, nid);
894 if (pin)
895 return pin->cfg;
896 pin = look_up_pincfg(codec, &codec->init_pins, nid);
897 if (pin)
898 return pin->cfg;
899 return 0;
900}
901EXPORT_SYMBOL_HDA(snd_hda_codec_get_pincfg);
902
903
904static void restore_pincfgs(struct hda_codec *codec)
905{
906 int i;
907 for (i = 0; i < codec->init_pins.used; i++) {
908 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
909 set_pincfg(codec, pin->nid,
910 snd_hda_codec_get_pincfg(codec, pin->nid));
911 }
912}
913
914
915
916
917
918
919
920
921void snd_hda_shutup_pins(struct hda_codec *codec)
922{
923 int i;
924
925
926
927 if (codec->bus->shutdown)
928 return;
929 for (i = 0; i < codec->init_pins.used; i++) {
930 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
931
932 snd_hda_codec_read(codec, pin->nid, 0,
933 AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
934 }
935 codec->pins_shutup = 1;
936}
937EXPORT_SYMBOL_HDA(snd_hda_shutup_pins);
938
939
940static void restore_shutup_pins(struct hda_codec *codec)
941{
942 int i;
943 if (!codec->pins_shutup)
944 return;
945 if (codec->bus->shutdown)
946 return;
947 for (i = 0; i < codec->init_pins.used; i++) {
948 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
949 snd_hda_codec_write(codec, pin->nid, 0,
950 AC_VERB_SET_PIN_WIDGET_CONTROL,
951 pin->ctrl);
952 }
953 codec->pins_shutup = 0;
954}
955
956static void init_hda_cache(struct hda_cache_rec *cache,
957 unsigned int record_size);
958static void free_hda_cache(struct hda_cache_rec *cache);
959
960
961static void restore_init_pincfgs(struct hda_codec *codec)
962{
963
964
965
966 snd_array_free(&codec->driver_pins);
967#ifdef CONFIG_SND_HDA_HWDEP
968 snd_array_free(&codec->user_pins);
969#endif
970 restore_pincfgs(codec);
971 snd_array_free(&codec->init_pins);
972}
973
974
975
976
977struct hda_cvt_setup {
978 hda_nid_t nid;
979 u8 stream_tag;
980 u8 channel_id;
981 u16 format_id;
982 unsigned char active;
983 unsigned char dirty;
984};
985
986
987static struct hda_cvt_setup *
988get_hda_cvt_setup(struct hda_codec *codec, hda_nid_t nid)
989{
990 struct hda_cvt_setup *p;
991 int i;
992
993 for (i = 0; i < codec->cvt_setups.used; i++) {
994 p = snd_array_elem(&codec->cvt_setups, i);
995 if (p->nid == nid)
996 return p;
997 }
998 p = snd_array_new(&codec->cvt_setups);
999 if (p)
1000 p->nid = nid;
1001 return p;
1002}
1003
1004
1005
1006
1007static void snd_hda_codec_free(struct hda_codec *codec)
1008{
1009 if (!codec)
1010 return;
1011 restore_init_pincfgs(codec);
1012#ifdef CONFIG_SND_HDA_POWER_SAVE
1013 cancel_delayed_work(&codec->power_work);
1014 flush_workqueue(codec->bus->workq);
1015#endif
1016 list_del(&codec->list);
1017 snd_array_free(&codec->mixers);
1018 snd_array_free(&codec->nids);
1019 codec->bus->caddr_tbl[codec->addr] = NULL;
1020 if (codec->patch_ops.free)
1021 codec->patch_ops.free(codec);
1022 module_put(codec->owner);
1023 free_hda_cache(&codec->amp_cache);
1024 free_hda_cache(&codec->cmd_cache);
1025 kfree(codec->vendor_name);
1026 kfree(codec->chip_name);
1027 kfree(codec->modelname);
1028 kfree(codec->wcaps);
1029 kfree(codec);
1030}
1031
1032static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
1033 unsigned int power_state);
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043int snd_hda_codec_new(struct hda_bus *bus,
1044 unsigned int codec_addr,
1045 struct hda_codec **codecp)
1046{
1047 struct hda_codec *codec;
1048 char component[31];
1049 int err;
1050
1051 if (snd_BUG_ON(!bus))
1052 return -EINVAL;
1053 if (snd_BUG_ON(codec_addr > HDA_MAX_CODEC_ADDRESS))
1054 return -EINVAL;
1055
1056 if (bus->caddr_tbl[codec_addr]) {
1057 snd_printk(KERN_ERR "hda_codec: "
1058 "address 0x%x is already occupied\n", codec_addr);
1059 return -EBUSY;
1060 }
1061
1062 codec = kzalloc(sizeof(*codec), GFP_KERNEL);
1063 if (codec == NULL) {
1064 snd_printk(KERN_ERR "can't allocate struct hda_codec\n");
1065 return -ENOMEM;
1066 }
1067
1068 codec->bus = bus;
1069 codec->addr = codec_addr;
1070 mutex_init(&codec->spdif_mutex);
1071 mutex_init(&codec->control_mutex);
1072 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
1073 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
1074 snd_array_init(&codec->mixers, sizeof(struct hda_nid_item), 32);
1075 snd_array_init(&codec->nids, sizeof(struct hda_nid_item), 32);
1076 snd_array_init(&codec->init_pins, sizeof(struct hda_pincfg), 16);
1077 snd_array_init(&codec->driver_pins, sizeof(struct hda_pincfg), 16);
1078 snd_array_init(&codec->cvt_setups, sizeof(struct hda_cvt_setup), 8);
1079 if (codec->bus->modelname) {
1080 codec->modelname = kstrdup(codec->bus->modelname, GFP_KERNEL);
1081 if (!codec->modelname) {
1082 snd_hda_codec_free(codec);
1083 return -ENODEV;
1084 }
1085 }
1086
1087#ifdef CONFIG_SND_HDA_POWER_SAVE
1088 INIT_DELAYED_WORK(&codec->power_work, hda_power_work);
1089
1090
1091
1092
1093 hda_keep_power_on(codec);
1094#endif
1095
1096 list_add_tail(&codec->list, &bus->codec_list);
1097 bus->caddr_tbl[codec_addr] = codec;
1098
1099 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1100 AC_PAR_VENDOR_ID);
1101 if (codec->vendor_id == -1)
1102
1103
1104
1105 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1106 AC_PAR_VENDOR_ID);
1107 codec->subsystem_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1108 AC_PAR_SUBSYSTEM_ID);
1109 codec->revision_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1110 AC_PAR_REV_ID);
1111
1112 setup_fg_nodes(codec);
1113 if (!codec->afg && !codec->mfg) {
1114 snd_printdd("hda_codec: no AFG or MFG node found\n");
1115 err = -ENODEV;
1116 goto error;
1117 }
1118
1119 err = read_widget_caps(codec, codec->afg ? codec->afg : codec->mfg);
1120 if (err < 0) {
1121 snd_printk(KERN_ERR "hda_codec: cannot malloc\n");
1122 goto error;
1123 }
1124 err = read_pin_defaults(codec);
1125 if (err < 0)
1126 goto error;
1127
1128 if (!codec->subsystem_id) {
1129 hda_nid_t nid = codec->afg ? codec->afg : codec->mfg;
1130 codec->subsystem_id =
1131 snd_hda_codec_read(codec, nid, 0,
1132 AC_VERB_GET_SUBSYSTEM_ID, 0);
1133 }
1134
1135
1136 hda_set_power_state(codec,
1137 codec->afg ? codec->afg : codec->mfg,
1138 AC_PWRST_D0);
1139
1140 snd_hda_codec_proc_new(codec);
1141
1142 snd_hda_create_hwdep(codec);
1143
1144 sprintf(component, "HDA:%08x,%08x,%08x", codec->vendor_id,
1145 codec->subsystem_id, codec->revision_id);
1146 snd_component_add(codec->bus->card, component);
1147
1148 if (codecp)
1149 *codecp = codec;
1150 return 0;
1151
1152 error:
1153 snd_hda_codec_free(codec);
1154 return err;
1155}
1156EXPORT_SYMBOL_HDA(snd_hda_codec_new);
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167int snd_hda_codec_configure(struct hda_codec *codec)
1168{
1169 int err;
1170
1171 codec->preset = find_codec_preset(codec);
1172 if (!codec->vendor_name || !codec->chip_name) {
1173 err = get_codec_name(codec);
1174 if (err < 0)
1175 return err;
1176 }
1177
1178 if (is_generic_config(codec)) {
1179 err = snd_hda_parse_generic_codec(codec);
1180 goto patched;
1181 }
1182 if (codec->preset && codec->preset->patch) {
1183 err = codec->preset->patch(codec);
1184 goto patched;
1185 }
1186
1187
1188 err = snd_hda_parse_generic_codec(codec);
1189 if (err < 0)
1190 printk(KERN_ERR "hda-codec: No codec parser is available\n");
1191
1192 patched:
1193 if (!err && codec->patch_ops.unsol_event)
1194 err = init_unsol_queue(codec->bus);
1195
1196 if (!err && (codec->afg || !*codec->bus->card->mixername))
1197 snprintf(codec->bus->card->mixername,
1198 sizeof(codec->bus->card->mixername),
1199 "%s %s", codec->vendor_name, codec->chip_name);
1200 return err;
1201}
1202EXPORT_SYMBOL_HDA(snd_hda_codec_configure);
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
1213 u32 stream_tag,
1214 int channel_id, int format)
1215{
1216 struct hda_codec *c;
1217 struct hda_cvt_setup *p;
1218 unsigned int oldval, newval;
1219 int type;
1220 int i;
1221
1222 if (!nid)
1223 return;
1224
1225 snd_printdd("hda_codec_setup_stream: "
1226 "NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
1227 nid, stream_tag, channel_id, format);
1228 p = get_hda_cvt_setup(codec, nid);
1229 if (!p)
1230 return;
1231
1232 if (p->stream_tag != stream_tag || p->channel_id != channel_id) {
1233 oldval = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONV, 0);
1234 newval = (stream_tag << 4) | channel_id;
1235 if (oldval != newval)
1236 snd_hda_codec_write(codec, nid, 0,
1237 AC_VERB_SET_CHANNEL_STREAMID,
1238 newval);
1239 p->stream_tag = stream_tag;
1240 p->channel_id = channel_id;
1241 }
1242
1243 if (p->format_id != format) {
1244 oldval = snd_hda_codec_read(codec, nid, 0,
1245 AC_VERB_GET_STREAM_FORMAT, 0);
1246 if (oldval != format) {
1247 msleep(1);
1248 snd_hda_codec_write(codec, nid, 0,
1249 AC_VERB_SET_STREAM_FORMAT,
1250 format);
1251 }
1252 p->format_id = format;
1253 }
1254 p->active = 1;
1255 p->dirty = 0;
1256
1257
1258 type = get_wcaps_type(get_wcaps(codec, nid));
1259 list_for_each_entry(c, &codec->bus->codec_list, list) {
1260 for (i = 0; i < c->cvt_setups.used; i++) {
1261 p = snd_array_elem(&c->cvt_setups, i);
1262 if (!p->active && p->stream_tag == stream_tag &&
1263 get_wcaps_type(get_wcaps(codec, p->nid)) == type)
1264 p->dirty = 1;
1265 }
1266 }
1267}
1268EXPORT_SYMBOL_HDA(snd_hda_codec_setup_stream);
1269
1270static void really_cleanup_stream(struct hda_codec *codec,
1271 struct hda_cvt_setup *q);
1272
1273
1274
1275
1276
1277
1278
1279void __snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid,
1280 int do_now)
1281{
1282 struct hda_cvt_setup *p;
1283
1284 if (!nid)
1285 return;
1286
1287 if (codec->no_sticky_stream)
1288 do_now = 1;
1289
1290 snd_printdd("hda_codec_cleanup_stream: NID=0x%x\n", nid);
1291 p = get_hda_cvt_setup(codec, nid);
1292 if (p) {
1293
1294
1295
1296
1297 if (do_now)
1298 really_cleanup_stream(codec, p);
1299 else
1300 p->active = 0;
1301 }
1302}
1303EXPORT_SYMBOL_HDA(__snd_hda_codec_cleanup_stream);
1304
1305static void really_cleanup_stream(struct hda_codec *codec,
1306 struct hda_cvt_setup *q)
1307{
1308 hda_nid_t nid = q->nid;
1309 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 0);
1310 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, 0);
1311 memset(q, 0, sizeof(*q));
1312 q->nid = nid;
1313}
1314
1315
1316static void purify_inactive_streams(struct hda_codec *codec)
1317{
1318 struct hda_codec *c;
1319 int i;
1320
1321 list_for_each_entry(c, &codec->bus->codec_list, list) {
1322 for (i = 0; i < c->cvt_setups.used; i++) {
1323 struct hda_cvt_setup *p;
1324 p = snd_array_elem(&c->cvt_setups, i);
1325 if (p->dirty)
1326 really_cleanup_stream(c, p);
1327 }
1328 }
1329}
1330
1331
1332static void hda_cleanup_all_streams(struct hda_codec *codec)
1333{
1334 int i;
1335
1336 for (i = 0; i < codec->cvt_setups.used; i++) {
1337 struct hda_cvt_setup *p = snd_array_elem(&codec->cvt_setups, i);
1338 if (p->stream_tag)
1339 really_cleanup_stream(codec, p);
1340 }
1341}
1342
1343
1344
1345
1346
1347
1348#define HDA_HASH_KEY(nid, dir, idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24))
1349#define HDA_HASH_PINCAP_KEY(nid) (u32)((nid) + (0x02 << 24))
1350#define HDA_HASH_PARPCM_KEY(nid) (u32)((nid) + (0x03 << 24))
1351#define HDA_HASH_PARSTR_KEY(nid) (u32)((nid) + (0x04 << 24))
1352#define INFO_AMP_CAPS (1<<0)
1353#define INFO_AMP_VOL(ch) (1 << (1 + (ch)))
1354
1355
1356static void init_hda_cache(struct hda_cache_rec *cache,
1357 unsigned int record_size)
1358{
1359 memset(cache, 0, sizeof(*cache));
1360 memset(cache->hash, 0xff, sizeof(cache->hash));
1361 snd_array_init(&cache->buf, record_size, 64);
1362}
1363
1364static void free_hda_cache(struct hda_cache_rec *cache)
1365{
1366 snd_array_free(&cache->buf);
1367}
1368
1369
1370static struct hda_cache_head *get_hash(struct hda_cache_rec *cache, u32 key)
1371{
1372 u16 idx = key % (u16)ARRAY_SIZE(cache->hash);
1373 u16 cur = cache->hash[idx];
1374 struct hda_cache_head *info;
1375
1376 while (cur != 0xffff) {
1377 info = snd_array_elem(&cache->buf, cur);
1378 if (info->key == key)
1379 return info;
1380 cur = info->next;
1381 }
1382 return NULL;
1383}
1384
1385
1386static struct hda_cache_head *get_alloc_hash(struct hda_cache_rec *cache,
1387 u32 key)
1388{
1389 struct hda_cache_head *info = get_hash(cache, key);
1390 if (!info) {
1391 u16 idx, cur;
1392
1393 info = snd_array_new(&cache->buf);
1394 if (!info)
1395 return NULL;
1396 cur = snd_array_index(&cache->buf, info);
1397 info->key = key;
1398 info->val = 0;
1399 idx = key % (u16)ARRAY_SIZE(cache->hash);
1400 info->next = cache->hash[idx];
1401 cache->hash[idx] = cur;
1402 }
1403 return info;
1404}
1405
1406
1407static inline struct hda_amp_info *
1408get_alloc_amp_hash(struct hda_codec *codec, u32 key)
1409{
1410 return (struct hda_amp_info *)get_alloc_hash(&codec->amp_cache, key);
1411}
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction)
1426{
1427 struct hda_amp_info *info;
1428
1429 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, 0));
1430 if (!info)
1431 return 0;
1432 if (!(info->head.val & INFO_AMP_CAPS)) {
1433 if (!(get_wcaps(codec, nid) & AC_WCAP_AMP_OVRD))
1434 nid = codec->afg;
1435 info->amp_caps = snd_hda_param_read(codec, nid,
1436 direction == HDA_OUTPUT ?
1437 AC_PAR_AMP_OUT_CAP :
1438 AC_PAR_AMP_IN_CAP);
1439 if (info->amp_caps)
1440 info->head.val |= INFO_AMP_CAPS;
1441 }
1442 return info->amp_caps;
1443}
1444EXPORT_SYMBOL_HDA(query_amp_caps);
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
1460 unsigned int caps)
1461{
1462 struct hda_amp_info *info;
1463
1464 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, dir, 0));
1465 if (!info)
1466 return -EINVAL;
1467 info->amp_caps = caps;
1468 info->head.val |= INFO_AMP_CAPS;
1469 return 0;
1470}
1471EXPORT_SYMBOL_HDA(snd_hda_override_amp_caps);
1472
1473static unsigned int
1474query_caps_hash(struct hda_codec *codec, hda_nid_t nid, u32 key,
1475 unsigned int (*func)(struct hda_codec *, hda_nid_t))
1476{
1477 struct hda_amp_info *info;
1478
1479 info = get_alloc_amp_hash(codec, key);
1480 if (!info)
1481 return 0;
1482 if (!info->head.val) {
1483 info->head.val |= INFO_AMP_CAPS;
1484 info->amp_caps = func(codec, nid);
1485 }
1486 return info->amp_caps;
1487}
1488
1489static unsigned int read_pin_cap(struct hda_codec *codec, hda_nid_t nid)
1490{
1491 return snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
1492}
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505u32 snd_hda_query_pin_caps(struct hda_codec *codec, hda_nid_t nid)
1506{
1507 return query_caps_hash(codec, nid, HDA_HASH_PINCAP_KEY(nid),
1508 read_pin_cap);
1509}
1510EXPORT_SYMBOL_HDA(snd_hda_query_pin_caps);
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520u32 snd_hda_pin_sense(struct hda_codec *codec, hda_nid_t nid)
1521{
1522 u32 pincap;
1523
1524 if (!codec->no_trigger_sense) {
1525 pincap = snd_hda_query_pin_caps(codec, nid);
1526 if (pincap & AC_PINCAP_TRIG_REQ)
1527 snd_hda_codec_read(codec, nid, 0,
1528 AC_VERB_SET_PIN_SENSE, 0);
1529 }
1530 return snd_hda_codec_read(codec, nid, 0,
1531 AC_VERB_GET_PIN_SENSE, 0);
1532}
1533EXPORT_SYMBOL_HDA(snd_hda_pin_sense);
1534
1535
1536
1537
1538
1539
1540
1541
1542int snd_hda_jack_detect(struct hda_codec *codec, hda_nid_t nid)
1543{
1544 u32 sense = snd_hda_pin_sense(codec, nid);
1545 return !!(sense & AC_PINSENSE_PRESENCE);
1546}
1547EXPORT_SYMBOL_HDA(snd_hda_jack_detect);
1548
1549
1550
1551
1552
1553static unsigned int get_vol_mute(struct hda_codec *codec,
1554 struct hda_amp_info *info, hda_nid_t nid,
1555 int ch, int direction, int index)
1556{
1557 u32 val, parm;
1558
1559 if (info->head.val & INFO_AMP_VOL(ch))
1560 return info->vol[ch];
1561
1562 parm = ch ? AC_AMP_GET_RIGHT : AC_AMP_GET_LEFT;
1563 parm |= direction == HDA_OUTPUT ? AC_AMP_GET_OUTPUT : AC_AMP_GET_INPUT;
1564 parm |= index;
1565 val = snd_hda_codec_read(codec, nid, 0,
1566 AC_VERB_GET_AMP_GAIN_MUTE, parm);
1567 info->vol[ch] = val & 0xff;
1568 info->head.val |= INFO_AMP_VOL(ch);
1569 return info->vol[ch];
1570}
1571
1572
1573
1574
1575static void put_vol_mute(struct hda_codec *codec, struct hda_amp_info *info,
1576 hda_nid_t nid, int ch, int direction, int index,
1577 int val)
1578{
1579 u32 parm;
1580
1581 parm = ch ? AC_AMP_SET_RIGHT : AC_AMP_SET_LEFT;
1582 parm |= direction == HDA_OUTPUT ? AC_AMP_SET_OUTPUT : AC_AMP_SET_INPUT;
1583 parm |= index << AC_AMP_SET_INDEX_SHIFT;
1584 parm |= val;
1585 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, parm);
1586 info->vol[ch] = val;
1587}
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch,
1600 int direction, int index)
1601{
1602 struct hda_amp_info *info;
1603 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, index));
1604 if (!info)
1605 return 0;
1606 return get_vol_mute(codec, info, nid, ch, direction, index);
1607}
1608EXPORT_SYMBOL_HDA(snd_hda_codec_amp_read);
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
1624 int direction, int idx, int mask, int val)
1625{
1626 struct hda_amp_info *info;
1627
1628 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, idx));
1629 if (!info)
1630 return 0;
1631 if (snd_BUG_ON(mask & ~0xff))
1632 mask &= 0xff;
1633 val &= mask;
1634 val |= get_vol_mute(codec, info, nid, ch, direction, idx) & ~mask;
1635 if (info->vol[ch] == val)
1636 return 0;
1637 put_vol_mute(codec, info, nid, ch, direction, idx, val);
1638 return 1;
1639}
1640EXPORT_SYMBOL_HDA(snd_hda_codec_amp_update);
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid,
1655 int direction, int idx, int mask, int val)
1656{
1657 int ch, ret = 0;
1658
1659 if (snd_BUG_ON(mask & ~0xff))
1660 mask &= 0xff;
1661 for (ch = 0; ch < 2; ch++)
1662 ret |= snd_hda_codec_amp_update(codec, nid, ch, direction,
1663 idx, mask, val);
1664 return ret;
1665}
1666EXPORT_SYMBOL_HDA(snd_hda_codec_amp_stereo);
1667
1668#ifdef SND_HDA_NEEDS_RESUME
1669
1670
1671
1672
1673
1674
1675void snd_hda_codec_resume_amp(struct hda_codec *codec)
1676{
1677 struct hda_amp_info *buffer = codec->amp_cache.buf.list;
1678 int i;
1679
1680 for (i = 0; i < codec->amp_cache.buf.used; i++, buffer++) {
1681 u32 key = buffer->head.key;
1682 hda_nid_t nid;
1683 unsigned int idx, dir, ch;
1684 if (!key)
1685 continue;
1686 nid = key & 0xff;
1687 idx = (key >> 16) & 0xff;
1688 dir = (key >> 24) & 0xff;
1689 for (ch = 0; ch < 2; ch++) {
1690 if (!(buffer->head.val & INFO_AMP_VOL(ch)))
1691 continue;
1692 put_vol_mute(codec, buffer, nid, ch, dir, idx,
1693 buffer->vol[ch]);
1694 }
1695 }
1696}
1697EXPORT_SYMBOL_HDA(snd_hda_codec_resume_amp);
1698#endif
1699
1700static u32 get_amp_max_value(struct hda_codec *codec, hda_nid_t nid, int dir,
1701 unsigned int ofs)
1702{
1703 u32 caps = query_amp_caps(codec, nid, dir);
1704
1705 caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1706 if (ofs < caps)
1707 caps -= ofs;
1708 return caps;
1709}
1710
1711
1712
1713
1714
1715
1716
1717int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
1718 struct snd_ctl_elem_info *uinfo)
1719{
1720 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1721 u16 nid = get_amp_nid(kcontrol);
1722 u8 chs = get_amp_channels(kcontrol);
1723 int dir = get_amp_direction(kcontrol);
1724 unsigned int ofs = get_amp_offset(kcontrol);
1725
1726 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1727 uinfo->count = chs == 3 ? 2 : 1;
1728 uinfo->value.integer.min = 0;
1729 uinfo->value.integer.max = get_amp_max_value(codec, nid, dir, ofs);
1730 if (!uinfo->value.integer.max) {
1731 printk(KERN_WARNING "hda_codec: "
1732 "num_steps = 0 for NID=0x%x (ctl = %s)\n", nid,
1733 kcontrol->id.name);
1734 return -EINVAL;
1735 }
1736 return 0;
1737}
1738EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_info);
1739
1740
1741static inline unsigned int
1742read_amp_value(struct hda_codec *codec, hda_nid_t nid,
1743 int ch, int dir, int idx, unsigned int ofs)
1744{
1745 unsigned int val;
1746 val = snd_hda_codec_amp_read(codec, nid, ch, dir, idx);
1747 val &= HDA_AMP_VOLMASK;
1748 if (val >= ofs)
1749 val -= ofs;
1750 else
1751 val = 0;
1752 return val;
1753}
1754
1755static inline int
1756update_amp_value(struct hda_codec *codec, hda_nid_t nid,
1757 int ch, int dir, int idx, unsigned int ofs,
1758 unsigned int val)
1759{
1760 unsigned int maxval;
1761
1762 if (val > 0)
1763 val += ofs;
1764
1765 maxval = get_amp_max_value(codec, nid, dir, 0);
1766 if (val > maxval)
1767 val = maxval;
1768 return snd_hda_codec_amp_update(codec, nid, ch, dir, idx,
1769 HDA_AMP_VOLMASK, val);
1770}
1771
1772
1773
1774
1775
1776
1777
1778int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
1779 struct snd_ctl_elem_value *ucontrol)
1780{
1781 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1782 hda_nid_t nid = get_amp_nid(kcontrol);
1783 int chs = get_amp_channels(kcontrol);
1784 int dir = get_amp_direction(kcontrol);
1785 int idx = get_amp_index(kcontrol);
1786 unsigned int ofs = get_amp_offset(kcontrol);
1787 long *valp = ucontrol->value.integer.value;
1788
1789 if (chs & 1)
1790 *valp++ = read_amp_value(codec, nid, 0, dir, idx, ofs);
1791 if (chs & 2)
1792 *valp = read_amp_value(codec, nid, 1, dir, idx, ofs);
1793 return 0;
1794}
1795EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_get);
1796
1797
1798
1799
1800
1801
1802
1803int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
1804 struct snd_ctl_elem_value *ucontrol)
1805{
1806 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1807 hda_nid_t nid = get_amp_nid(kcontrol);
1808 int chs = get_amp_channels(kcontrol);
1809 int dir = get_amp_direction(kcontrol);
1810 int idx = get_amp_index(kcontrol);
1811 unsigned int ofs = get_amp_offset(kcontrol);
1812 long *valp = ucontrol->value.integer.value;
1813 int change = 0;
1814
1815 snd_hda_power_up(codec);
1816 if (chs & 1) {
1817 change = update_amp_value(codec, nid, 0, dir, idx, ofs, *valp);
1818 valp++;
1819 }
1820 if (chs & 2)
1821 change |= update_amp_value(codec, nid, 1, dir, idx, ofs, *valp);
1822 snd_hda_power_down(codec);
1823 return change;
1824}
1825EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_put);
1826
1827
1828
1829
1830
1831
1832
1833int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1834 unsigned int size, unsigned int __user *_tlv)
1835{
1836 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1837 hda_nid_t nid = get_amp_nid(kcontrol);
1838 int dir = get_amp_direction(kcontrol);
1839 unsigned int ofs = get_amp_offset(kcontrol);
1840 bool min_mute = get_amp_min_mute(kcontrol);
1841 u32 caps, val1, val2;
1842
1843 if (size < 4 * sizeof(unsigned int))
1844 return -ENOMEM;
1845 caps = query_amp_caps(codec, nid, dir);
1846 val2 = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1847 val2 = (val2 + 1) * 25;
1848 val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT);
1849 val1 += ofs;
1850 val1 = ((int)val1) * ((int)val2);
1851 if (min_mute)
1852 val2 |= TLV_DB_SCALE_MUTE;
1853 if (put_user(SNDRV_CTL_TLVT_DB_SCALE, _tlv))
1854 return -EFAULT;
1855 if (put_user(2 * sizeof(unsigned int), _tlv + 1))
1856 return -EFAULT;
1857 if (put_user(val1, _tlv + 2))
1858 return -EFAULT;
1859 if (put_user(val2, _tlv + 3))
1860 return -EFAULT;
1861 return 0;
1862}
1863EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_tlv);
1864
1865
1866
1867
1868
1869
1870
1871
1872
1873
1874
1875
1876void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir,
1877 unsigned int *tlv)
1878{
1879 u32 caps;
1880 int nums, step;
1881
1882 caps = query_amp_caps(codec, nid, dir);
1883 nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1884 step = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1885 step = (step + 1) * 25;
1886 tlv[0] = SNDRV_CTL_TLVT_DB_SCALE;
1887 tlv[1] = 2 * sizeof(unsigned int);
1888 tlv[2] = -nums * step;
1889 tlv[3] = step;
1890}
1891EXPORT_SYMBOL_HDA(snd_hda_set_vmaster_tlv);
1892
1893
1894static struct snd_kcontrol *
1895_snd_hda_find_mixer_ctl(struct hda_codec *codec,
1896 const char *name, int idx)
1897{
1898 struct snd_ctl_elem_id id;
1899 memset(&id, 0, sizeof(id));
1900 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1901 id.index = idx;
1902 if (snd_BUG_ON(strlen(name) >= sizeof(id.name)))
1903 return NULL;
1904 strcpy(id.name, name);
1905 return snd_ctl_find_id(codec->bus->card, &id);
1906}
1907
1908
1909
1910
1911
1912
1913
1914
1915struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
1916 const char *name)
1917{
1918 return _snd_hda_find_mixer_ctl(codec, name, 0);
1919}
1920EXPORT_SYMBOL_HDA(snd_hda_find_mixer_ctl);
1921
1922static int find_empty_mixer_ctl_idx(struct hda_codec *codec, const char *name)
1923{
1924 int idx;
1925 for (idx = 0; idx < 16; idx++) {
1926 if (!_snd_hda_find_mixer_ctl(codec, name, idx))
1927 return idx;
1928 }
1929 return -EBUSY;
1930}
1931
1932
1933
1934
1935
1936
1937
1938
1939
1940
1941
1942
1943
1944
1945
1946
1947
1948
1949
1950
1951int snd_hda_ctl_add(struct hda_codec *codec, hda_nid_t nid,
1952 struct snd_kcontrol *kctl)
1953{
1954 int err;
1955 unsigned short flags = 0;
1956 struct hda_nid_item *item;
1957
1958 if (kctl->id.subdevice & HDA_SUBDEV_AMP_FLAG) {
1959 flags |= HDA_NID_ITEM_AMP;
1960 if (nid == 0)
1961 nid = get_amp_nid_(kctl->private_value);
1962 }
1963 if ((kctl->id.subdevice & HDA_SUBDEV_NID_FLAG) != 0 && nid == 0)
1964 nid = kctl->id.subdevice & 0xffff;
1965 if (kctl->id.subdevice & (HDA_SUBDEV_NID_FLAG|HDA_SUBDEV_AMP_FLAG))
1966 kctl->id.subdevice = 0;
1967 err = snd_ctl_add(codec->bus->card, kctl);
1968 if (err < 0)
1969 return err;
1970 item = snd_array_new(&codec->mixers);
1971 if (!item)
1972 return -ENOMEM;
1973 item->kctl = kctl;
1974 item->nid = nid;
1975 item->flags = flags;
1976 return 0;
1977}
1978EXPORT_SYMBOL_HDA(snd_hda_ctl_add);
1979
1980
1981
1982
1983
1984
1985
1986
1987
1988
1989
1990
1991int snd_hda_add_nid(struct hda_codec *codec, struct snd_kcontrol *kctl,
1992 unsigned int index, hda_nid_t nid)
1993{
1994 struct hda_nid_item *item;
1995
1996 if (nid > 0) {
1997 item = snd_array_new(&codec->nids);
1998 if (!item)
1999 return -ENOMEM;
2000 item->kctl = kctl;
2001 item->index = index;
2002 item->nid = nid;
2003 return 0;
2004 }
2005 printk(KERN_ERR "hda-codec: no NID for mapping control %s:%d:%d\n",
2006 kctl->id.name, kctl->id.index, index);
2007 return -EINVAL;
2008}
2009EXPORT_SYMBOL_HDA(snd_hda_add_nid);
2010
2011
2012
2013
2014
2015void snd_hda_ctls_clear(struct hda_codec *codec)
2016{
2017 int i;
2018 struct hda_nid_item *items = codec->mixers.list;
2019 for (i = 0; i < codec->mixers.used; i++)
2020 snd_ctl_remove(codec->bus->card, items[i].kctl);
2021 snd_array_free(&codec->mixers);
2022 snd_array_free(&codec->nids);
2023}
2024
2025
2026
2027
2028static int hda_lock_devices(struct snd_card *card)
2029{
2030 spin_lock(&card->files_lock);
2031 if (card->shutdown) {
2032 spin_unlock(&card->files_lock);
2033 return -EINVAL;
2034 }
2035 card->shutdown = 1;
2036 spin_unlock(&card->files_lock);
2037 return 0;
2038}
2039
2040static void hda_unlock_devices(struct snd_card *card)
2041{
2042 spin_lock(&card->files_lock);
2043 card->shutdown = 0;
2044 spin_unlock(&card->files_lock);
2045}
2046
2047
2048
2049
2050
2051
2052
2053
2054
2055
2056
2057int snd_hda_codec_reset(struct hda_codec *codec)
2058{
2059 struct snd_card *card = codec->bus->card;
2060 int i, pcm;
2061
2062 if (hda_lock_devices(card) < 0)
2063 return -EBUSY;
2064
2065 if (!list_empty(&card->ctl_files)) {
2066 hda_unlock_devices(card);
2067 return -EBUSY;
2068 }
2069 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
2070 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
2071 if (!cpcm->pcm)
2072 continue;
2073 if (cpcm->pcm->streams[0].substream_opened ||
2074 cpcm->pcm->streams[1].substream_opened) {
2075 hda_unlock_devices(card);
2076 return -EBUSY;
2077 }
2078 }
2079
2080
2081
2082#ifdef CONFIG_SND_HDA_POWER_SAVE
2083 cancel_delayed_work(&codec->power_work);
2084 flush_workqueue(codec->bus->workq);
2085#endif
2086 snd_hda_ctls_clear(codec);
2087
2088 for (i = 0; i < codec->num_pcms; i++) {
2089 if (codec->pcm_info[i].pcm) {
2090 snd_device_free(card, codec->pcm_info[i].pcm);
2091 clear_bit(codec->pcm_info[i].device,
2092 codec->bus->pcm_dev_bits);
2093 }
2094 }
2095 if (codec->patch_ops.free)
2096 codec->patch_ops.free(codec);
2097 codec->proc_widget_hook = NULL;
2098 codec->spec = NULL;
2099 free_hda_cache(&codec->amp_cache);
2100 free_hda_cache(&codec->cmd_cache);
2101 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
2102 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
2103
2104 snd_array_free(&codec->driver_pins);
2105 restore_pincfgs(codec);
2106 codec->num_pcms = 0;
2107 codec->pcm_info = NULL;
2108 codec->preset = NULL;
2109 memset(&codec->patch_ops, 0, sizeof(codec->patch_ops));
2110 codec->slave_dig_outs = NULL;
2111 codec->spdif_status_reset = 0;
2112 module_put(codec->owner);
2113 codec->owner = NULL;
2114
2115
2116 hda_unlock_devices(card);
2117 return 0;
2118}
2119
2120
2121
2122
2123
2124
2125
2126
2127
2128
2129
2130
2131
2132
2133
2134
2135
2136int snd_hda_add_vmaster(struct hda_codec *codec, char *name,
2137 unsigned int *tlv, const char * const *slaves)
2138{
2139 struct snd_kcontrol *kctl;
2140 const char * const *s;
2141 int err;
2142
2143 for (s = slaves; *s && !snd_hda_find_mixer_ctl(codec, *s); s++)
2144 ;
2145 if (!*s) {
2146 snd_printdd("No slave found for %s\n", name);
2147 return 0;
2148 }
2149 kctl = snd_ctl_make_virtual_master(name, tlv);
2150 if (!kctl)
2151 return -ENOMEM;
2152 err = snd_hda_ctl_add(codec, 0, kctl);
2153 if (err < 0)
2154 return err;
2155
2156 for (s = slaves; *s; s++) {
2157 struct snd_kcontrol *sctl;
2158 int i = 0;
2159 for (;;) {
2160 sctl = _snd_hda_find_mixer_ctl(codec, *s, i);
2161 if (!sctl) {
2162 if (!i)
2163 snd_printdd("Cannot find slave %s, "
2164 "skipped\n", *s);
2165 break;
2166 }
2167 err = snd_ctl_add_slave(kctl, sctl);
2168 if (err < 0)
2169 return err;
2170 i++;
2171 }
2172 }
2173 return 0;
2174}
2175EXPORT_SYMBOL_HDA(snd_hda_add_vmaster);
2176
2177
2178
2179
2180
2181
2182
2183int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
2184 struct snd_ctl_elem_info *uinfo)
2185{
2186 int chs = get_amp_channels(kcontrol);
2187
2188 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2189 uinfo->count = chs == 3 ? 2 : 1;
2190 uinfo->value.integer.min = 0;
2191 uinfo->value.integer.max = 1;
2192 return 0;
2193}
2194EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_info);
2195
2196
2197
2198
2199
2200
2201
2202int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
2203 struct snd_ctl_elem_value *ucontrol)
2204{
2205 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2206 hda_nid_t nid = get_amp_nid(kcontrol);
2207 int chs = get_amp_channels(kcontrol);
2208 int dir = get_amp_direction(kcontrol);
2209 int idx = get_amp_index(kcontrol);
2210 long *valp = ucontrol->value.integer.value;
2211
2212 if (chs & 1)
2213 *valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) &
2214 HDA_AMP_MUTE) ? 0 : 1;
2215 if (chs & 2)
2216 *valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) &
2217 HDA_AMP_MUTE) ? 0 : 1;
2218 return 0;
2219}
2220EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_get);
2221
2222
2223
2224
2225
2226
2227
2228int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
2229 struct snd_ctl_elem_value *ucontrol)
2230{
2231 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2232 hda_nid_t nid = get_amp_nid(kcontrol);
2233 int chs = get_amp_channels(kcontrol);
2234 int dir = get_amp_direction(kcontrol);
2235 int idx = get_amp_index(kcontrol);
2236 long *valp = ucontrol->value.integer.value;
2237 int change = 0;
2238
2239 snd_hda_power_up(codec);
2240 if (chs & 1) {
2241 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
2242 HDA_AMP_MUTE,
2243 *valp ? 0 : HDA_AMP_MUTE);
2244 valp++;
2245 }
2246 if (chs & 2)
2247 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
2248 HDA_AMP_MUTE,
2249 *valp ? 0 : HDA_AMP_MUTE);
2250 hda_call_check_power_status(codec, nid);
2251 snd_hda_power_down(codec);
2252 return change;
2253}
2254EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put);
2255
2256#ifdef CONFIG_SND_HDA_INPUT_BEEP
2257
2258
2259
2260
2261
2262
2263int snd_hda_mixer_amp_switch_put_beep(struct snd_kcontrol *kcontrol,
2264 struct snd_ctl_elem_value *ucontrol)
2265{
2266 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2267 long *valp = ucontrol->value.integer.value;
2268
2269 snd_hda_enable_beep_device(codec, *valp);
2270 return snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2271}
2272EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put_beep);
2273#endif
2274
2275
2276
2277
2278
2279
2280
2281#define AMP_VAL_IDX_SHIFT 19
2282#define AMP_VAL_IDX_MASK (0x0f<<19)
2283
2284
2285
2286
2287
2288
2289
2290int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
2291 struct snd_ctl_elem_value *ucontrol)
2292{
2293 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2294 unsigned long pval;
2295 int err;
2296
2297 mutex_lock(&codec->control_mutex);
2298 pval = kcontrol->private_value;
2299 kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK;
2300 err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
2301 kcontrol->private_value = pval;
2302 mutex_unlock(&codec->control_mutex);
2303 return err;
2304}
2305EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_get);
2306
2307
2308
2309
2310
2311
2312
2313int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
2314 struct snd_ctl_elem_value *ucontrol)
2315{
2316 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2317 unsigned long pval;
2318 int i, indices, err = 0, change = 0;
2319
2320 mutex_lock(&codec->control_mutex);
2321 pval = kcontrol->private_value;
2322 indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
2323 for (i = 0; i < indices; i++) {
2324 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
2325 (i << AMP_VAL_IDX_SHIFT);
2326 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2327 if (err < 0)
2328 break;
2329 change |= err;
2330 }
2331 kcontrol->private_value = pval;
2332 mutex_unlock(&codec->control_mutex);
2333 return err < 0 ? err : change;
2334}
2335EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_put);
2336
2337
2338
2339
2340
2341
2342
2343int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
2344 struct snd_ctl_elem_info *uinfo)
2345{
2346 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2347 struct hda_bind_ctls *c;
2348 int err;
2349
2350 mutex_lock(&codec->control_mutex);
2351 c = (struct hda_bind_ctls *)kcontrol->private_value;
2352 kcontrol->private_value = *c->values;
2353 err = c->ops->info(kcontrol, uinfo);
2354 kcontrol->private_value = (long)c;
2355 mutex_unlock(&codec->control_mutex);
2356 return err;
2357}
2358EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_info);
2359
2360
2361
2362
2363
2364
2365
2366int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
2367 struct snd_ctl_elem_value *ucontrol)
2368{
2369 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2370 struct hda_bind_ctls *c;
2371 int err;
2372
2373 mutex_lock(&codec->control_mutex);
2374 c = (struct hda_bind_ctls *)kcontrol->private_value;
2375 kcontrol->private_value = *c->values;
2376 err = c->ops->get(kcontrol, ucontrol);
2377 kcontrol->private_value = (long)c;
2378 mutex_unlock(&codec->control_mutex);
2379 return err;
2380}
2381EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_get);
2382
2383
2384
2385
2386
2387
2388
2389int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
2390 struct snd_ctl_elem_value *ucontrol)
2391{
2392 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2393 struct hda_bind_ctls *c;
2394 unsigned long *vals;
2395 int err = 0, change = 0;
2396
2397 mutex_lock(&codec->control_mutex);
2398 c = (struct hda_bind_ctls *)kcontrol->private_value;
2399 for (vals = c->values; *vals; vals++) {
2400 kcontrol->private_value = *vals;
2401 err = c->ops->put(kcontrol, ucontrol);
2402 if (err < 0)
2403 break;
2404 change |= err;
2405 }
2406 kcontrol->private_value = (long)c;
2407 mutex_unlock(&codec->control_mutex);
2408 return err < 0 ? err : change;
2409}
2410EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_put);
2411
2412
2413
2414
2415
2416
2417
2418int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
2419 unsigned int size, unsigned int __user *tlv)
2420{
2421 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2422 struct hda_bind_ctls *c;
2423 int err;
2424
2425 mutex_lock(&codec->control_mutex);
2426 c = (struct hda_bind_ctls *)kcontrol->private_value;
2427 kcontrol->private_value = *c->values;
2428 err = c->ops->tlv(kcontrol, op_flag, size, tlv);
2429 kcontrol->private_value = (long)c;
2430 mutex_unlock(&codec->control_mutex);
2431 return err;
2432}
2433EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_tlv);
2434
2435struct hda_ctl_ops snd_hda_bind_vol = {
2436 .info = snd_hda_mixer_amp_volume_info,
2437 .get = snd_hda_mixer_amp_volume_get,
2438 .put = snd_hda_mixer_amp_volume_put,
2439 .tlv = snd_hda_mixer_amp_tlv
2440};
2441EXPORT_SYMBOL_HDA(snd_hda_bind_vol);
2442
2443struct hda_ctl_ops snd_hda_bind_sw = {
2444 .info = snd_hda_mixer_amp_switch_info,
2445 .get = snd_hda_mixer_amp_switch_get,
2446 .put = snd_hda_mixer_amp_switch_put,
2447 .tlv = snd_hda_mixer_amp_tlv
2448};
2449EXPORT_SYMBOL_HDA(snd_hda_bind_sw);
2450
2451
2452
2453
2454
2455static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol,
2456 struct snd_ctl_elem_info *uinfo)
2457{
2458 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
2459 uinfo->count = 1;
2460 return 0;
2461}
2462
2463static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol,
2464 struct snd_ctl_elem_value *ucontrol)
2465{
2466 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
2467 IEC958_AES0_NONAUDIO |
2468 IEC958_AES0_CON_EMPHASIS_5015 |
2469 IEC958_AES0_CON_NOT_COPYRIGHT;
2470 ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
2471 IEC958_AES1_CON_ORIGINAL;
2472 return 0;
2473}
2474
2475static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol,
2476 struct snd_ctl_elem_value *ucontrol)
2477{
2478 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
2479 IEC958_AES0_NONAUDIO |
2480 IEC958_AES0_PRO_EMPHASIS_5015;
2481 return 0;
2482}
2483
2484static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
2485 struct snd_ctl_elem_value *ucontrol)
2486{
2487 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2488
2489 ucontrol->value.iec958.status[0] = codec->spdif_status & 0xff;
2490 ucontrol->value.iec958.status[1] = (codec->spdif_status >> 8) & 0xff;
2491 ucontrol->value.iec958.status[2] = (codec->spdif_status >> 16) & 0xff;
2492 ucontrol->value.iec958.status[3] = (codec->spdif_status >> 24) & 0xff;
2493
2494 return 0;
2495}
2496
2497
2498
2499
2500static unsigned short convert_from_spdif_status(unsigned int sbits)
2501{
2502 unsigned short val = 0;
2503
2504 if (sbits & IEC958_AES0_PROFESSIONAL)
2505 val |= AC_DIG1_PROFESSIONAL;
2506 if (sbits & IEC958_AES0_NONAUDIO)
2507 val |= AC_DIG1_NONAUDIO;
2508 if (sbits & IEC958_AES0_PROFESSIONAL) {
2509 if ((sbits & IEC958_AES0_PRO_EMPHASIS) ==
2510 IEC958_AES0_PRO_EMPHASIS_5015)
2511 val |= AC_DIG1_EMPHASIS;
2512 } else {
2513 if ((sbits & IEC958_AES0_CON_EMPHASIS) ==
2514 IEC958_AES0_CON_EMPHASIS_5015)
2515 val |= AC_DIG1_EMPHASIS;
2516 if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
2517 val |= AC_DIG1_COPYRIGHT;
2518 if (sbits & (IEC958_AES1_CON_ORIGINAL << 8))
2519 val |= AC_DIG1_LEVEL;
2520 val |= sbits & (IEC958_AES1_CON_CATEGORY << 8);
2521 }
2522 return val;
2523}
2524
2525
2526
2527static unsigned int convert_to_spdif_status(unsigned short val)
2528{
2529 unsigned int sbits = 0;
2530
2531 if (val & AC_DIG1_NONAUDIO)
2532 sbits |= IEC958_AES0_NONAUDIO;
2533 if (val & AC_DIG1_PROFESSIONAL)
2534 sbits |= IEC958_AES0_PROFESSIONAL;
2535 if (sbits & IEC958_AES0_PROFESSIONAL) {
2536 if (sbits & AC_DIG1_EMPHASIS)
2537 sbits |= IEC958_AES0_PRO_EMPHASIS_5015;
2538 } else {
2539 if (val & AC_DIG1_EMPHASIS)
2540 sbits |= IEC958_AES0_CON_EMPHASIS_5015;
2541 if (!(val & AC_DIG1_COPYRIGHT))
2542 sbits |= IEC958_AES0_CON_NOT_COPYRIGHT;
2543 if (val & AC_DIG1_LEVEL)
2544 sbits |= (IEC958_AES1_CON_ORIGINAL << 8);
2545 sbits |= val & (0x7f << 8);
2546 }
2547 return sbits;
2548}
2549
2550
2551static void set_dig_out(struct hda_codec *codec, hda_nid_t nid,
2552 int verb, int val)
2553{
2554 hda_nid_t *d;
2555
2556 snd_hda_codec_write_cache(codec, nid, 0, verb, val);
2557 d = codec->slave_dig_outs;
2558 if (!d)
2559 return;
2560 for (; *d; d++)
2561 snd_hda_codec_write_cache(codec, *d, 0, verb, val);
2562}
2563
2564static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid,
2565 int dig1, int dig2)
2566{
2567 if (dig1 != -1)
2568 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_1, dig1);
2569 if (dig2 != -1)
2570 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_2, dig2);
2571}
2572
2573static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
2574 struct snd_ctl_elem_value *ucontrol)
2575{
2576 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2577 hda_nid_t nid = kcontrol->private_value;
2578 unsigned short val;
2579 int change;
2580
2581 mutex_lock(&codec->spdif_mutex);
2582 codec->spdif_status = ucontrol->value.iec958.status[0] |
2583 ((unsigned int)ucontrol->value.iec958.status[1] << 8) |
2584 ((unsigned int)ucontrol->value.iec958.status[2] << 16) |
2585 ((unsigned int)ucontrol->value.iec958.status[3] << 24);
2586 val = convert_from_spdif_status(codec->spdif_status);
2587 val |= codec->spdif_ctls & 1;
2588 change = codec->spdif_ctls != val;
2589 codec->spdif_ctls = val;
2590
2591 if (change)
2592 set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
2593
2594 mutex_unlock(&codec->spdif_mutex);
2595 return change;
2596}
2597
2598#define snd_hda_spdif_out_switch_info snd_ctl_boolean_mono_info
2599
2600static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
2601 struct snd_ctl_elem_value *ucontrol)
2602{
2603 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2604
2605 ucontrol->value.integer.value[0] = codec->spdif_ctls & AC_DIG1_ENABLE;
2606 return 0;
2607}
2608
2609static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
2610 struct snd_ctl_elem_value *ucontrol)
2611{
2612 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2613 hda_nid_t nid = kcontrol->private_value;
2614 unsigned short val;
2615 int change;
2616
2617 mutex_lock(&codec->spdif_mutex);
2618 val = codec->spdif_ctls & ~AC_DIG1_ENABLE;
2619 if (ucontrol->value.integer.value[0])
2620 val |= AC_DIG1_ENABLE;
2621 change = codec->spdif_ctls != val;
2622 if (change) {
2623 codec->spdif_ctls = val;
2624 set_dig_out_convert(codec, nid, val & 0xff, -1);
2625
2626 if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
2627 (val & AC_DIG1_ENABLE))
2628 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
2629 HDA_AMP_MUTE, 0);
2630 }
2631 mutex_unlock(&codec->spdif_mutex);
2632 return change;
2633}
2634
2635static struct snd_kcontrol_new dig_mixes[] = {
2636 {
2637 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2638 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2639 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, CON_MASK),
2640 .info = snd_hda_spdif_mask_info,
2641 .get = snd_hda_spdif_cmask_get,
2642 },
2643 {
2644 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2645 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2646 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, PRO_MASK),
2647 .info = snd_hda_spdif_mask_info,
2648 .get = snd_hda_spdif_pmask_get,
2649 },
2650 {
2651 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2652 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT),
2653 .info = snd_hda_spdif_mask_info,
2654 .get = snd_hda_spdif_default_get,
2655 .put = snd_hda_spdif_default_put,
2656 },
2657 {
2658 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2659 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH),
2660 .info = snd_hda_spdif_out_switch_info,
2661 .get = snd_hda_spdif_out_switch_get,
2662 .put = snd_hda_spdif_out_switch_put,
2663 },
2664 { }
2665};
2666
2667
2668
2669
2670
2671
2672
2673
2674
2675
2676
2677int snd_hda_create_spdif_out_ctls(struct hda_codec *codec, hda_nid_t nid)
2678{
2679 int err;
2680 struct snd_kcontrol *kctl;
2681 struct snd_kcontrol_new *dig_mix;
2682 int idx;
2683
2684 idx = find_empty_mixer_ctl_idx(codec, "IEC958 Playback Switch");
2685 if (idx < 0) {
2686 printk(KERN_ERR "hda_codec: too many IEC958 outputs\n");
2687 return -EBUSY;
2688 }
2689 for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
2690 kctl = snd_ctl_new1(dig_mix, codec);
2691 if (!kctl)
2692 return -ENOMEM;
2693 kctl->id.index = idx;
2694 kctl->private_value = nid;
2695 err = snd_hda_ctl_add(codec, nid, kctl);
2696 if (err < 0)
2697 return err;
2698 }
2699 codec->spdif_ctls =
2700 snd_hda_codec_read(codec, nid, 0,
2701 AC_VERB_GET_DIGI_CONVERT_1, 0);
2702 codec->spdif_status = convert_to_spdif_status(codec->spdif_ctls);
2703 return 0;
2704}
2705EXPORT_SYMBOL_HDA(snd_hda_create_spdif_out_ctls);
2706
2707
2708
2709
2710static int spdif_share_sw_get(struct snd_kcontrol *kcontrol,
2711 struct snd_ctl_elem_value *ucontrol)
2712{
2713 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
2714 ucontrol->value.integer.value[0] = mout->share_spdif;
2715 return 0;
2716}
2717
2718static int spdif_share_sw_put(struct snd_kcontrol *kcontrol,
2719 struct snd_ctl_elem_value *ucontrol)
2720{
2721 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
2722 mout->share_spdif = !!ucontrol->value.integer.value[0];
2723 return 0;
2724}
2725
2726static struct snd_kcontrol_new spdif_share_sw = {
2727 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2728 .name = "IEC958 Default PCM Playback Switch",
2729 .info = snd_ctl_boolean_mono_info,
2730 .get = spdif_share_sw_get,
2731 .put = spdif_share_sw_put,
2732};
2733
2734
2735
2736
2737
2738
2739int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
2740 struct hda_multi_out *mout)
2741{
2742 if (!mout->dig_out_nid)
2743 return 0;
2744
2745 return snd_hda_ctl_add(codec, mout->dig_out_nid,
2746 snd_ctl_new1(&spdif_share_sw, mout));
2747}
2748EXPORT_SYMBOL_HDA(snd_hda_create_spdif_share_sw);
2749
2750
2751
2752
2753
2754#define snd_hda_spdif_in_switch_info snd_hda_spdif_out_switch_info
2755
2756static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
2757 struct snd_ctl_elem_value *ucontrol)
2758{
2759 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2760
2761 ucontrol->value.integer.value[0] = codec->spdif_in_enable;
2762 return 0;
2763}
2764
2765static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
2766 struct snd_ctl_elem_value *ucontrol)
2767{
2768 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2769 hda_nid_t nid = kcontrol->private_value;
2770 unsigned int val = !!ucontrol->value.integer.value[0];
2771 int change;
2772
2773 mutex_lock(&codec->spdif_mutex);
2774 change = codec->spdif_in_enable != val;
2775 if (change) {
2776 codec->spdif_in_enable = val;
2777 snd_hda_codec_write_cache(codec, nid, 0,
2778 AC_VERB_SET_DIGI_CONVERT_1, val);
2779 }
2780 mutex_unlock(&codec->spdif_mutex);
2781 return change;
2782}
2783
2784static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
2785 struct snd_ctl_elem_value *ucontrol)
2786{
2787 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2788 hda_nid_t nid = kcontrol->private_value;
2789 unsigned short val;
2790 unsigned int sbits;
2791
2792 val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DIGI_CONVERT_1, 0);
2793 sbits = convert_to_spdif_status(val);
2794 ucontrol->value.iec958.status[0] = sbits;
2795 ucontrol->value.iec958.status[1] = sbits >> 8;
2796 ucontrol->value.iec958.status[2] = sbits >> 16;
2797 ucontrol->value.iec958.status[3] = sbits >> 24;
2798 return 0;
2799}
2800
2801static struct snd_kcontrol_new dig_in_ctls[] = {
2802 {
2803 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2804 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, SWITCH),
2805 .info = snd_hda_spdif_in_switch_info,
2806 .get = snd_hda_spdif_in_switch_get,
2807 .put = snd_hda_spdif_in_switch_put,
2808 },
2809 {
2810 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2811 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2812 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, DEFAULT),
2813 .info = snd_hda_spdif_mask_info,
2814 .get = snd_hda_spdif_in_status_get,
2815 },
2816 { }
2817};
2818
2819
2820
2821
2822
2823
2824
2825
2826
2827
2828
2829int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
2830{
2831 int err;
2832 struct snd_kcontrol *kctl;
2833 struct snd_kcontrol_new *dig_mix;
2834 int idx;
2835
2836 idx = find_empty_mixer_ctl_idx(codec, "IEC958 Capture Switch");
2837 if (idx < 0) {
2838 printk(KERN_ERR "hda_codec: too many IEC958 inputs\n");
2839 return -EBUSY;
2840 }
2841 for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
2842 kctl = snd_ctl_new1(dig_mix, codec);
2843 if (!kctl)
2844 return -ENOMEM;
2845 kctl->private_value = nid;
2846 err = snd_hda_ctl_add(codec, nid, kctl);
2847 if (err < 0)
2848 return err;
2849 }
2850 codec->spdif_in_enable =
2851 snd_hda_codec_read(codec, nid, 0,
2852 AC_VERB_GET_DIGI_CONVERT_1, 0) &
2853 AC_DIG1_ENABLE;
2854 return 0;
2855}
2856EXPORT_SYMBOL_HDA(snd_hda_create_spdif_in_ctls);
2857
2858#ifdef SND_HDA_NEEDS_RESUME
2859
2860
2861
2862
2863
2864#define build_cmd_cache_key(nid, verb) ((verb << 8) | nid)
2865#define get_cmd_cache_nid(key) ((key) & 0xff)
2866#define get_cmd_cache_cmd(key) (((key) >> 8) & 0xffff)
2867
2868
2869
2870
2871
2872
2873
2874
2875
2876
2877
2878
2879
2880int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
2881 int direct, unsigned int verb, unsigned int parm)
2882{
2883 int err = snd_hda_codec_write(codec, nid, direct, verb, parm);
2884 struct hda_cache_head *c;
2885 u32 key;
2886
2887 if (err < 0)
2888 return err;
2889
2890 verb = verb | (parm >> 8);
2891 parm &= 0xff;
2892 key = build_cmd_cache_key(nid, verb);
2893 mutex_lock(&codec->bus->cmd_mutex);
2894 c = get_alloc_hash(&codec->cmd_cache, key);
2895 if (c)
2896 c->val = parm;
2897 mutex_unlock(&codec->bus->cmd_mutex);
2898 return 0;
2899}
2900EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache);
2901
2902
2903
2904
2905
2906
2907
2908
2909
2910
2911
2912
2913
2914
2915
2916int snd_hda_codec_update_cache(struct hda_codec *codec, hda_nid_t nid,
2917 int direct, unsigned int verb, unsigned int parm)
2918{
2919 struct hda_cache_head *c;
2920 u32 key;
2921
2922
2923 verb = verb | (parm >> 8);
2924 parm &= 0xff;
2925 key = build_cmd_cache_key(nid, verb);
2926 mutex_lock(&codec->bus->cmd_mutex);
2927 c = get_hash(&codec->cmd_cache, key);
2928 if (c && c->val == parm) {
2929 mutex_unlock(&codec->bus->cmd_mutex);
2930 return 0;
2931 }
2932 mutex_unlock(&codec->bus->cmd_mutex);
2933 return snd_hda_codec_write_cache(codec, nid, direct, verb, parm);
2934}
2935EXPORT_SYMBOL_HDA(snd_hda_codec_update_cache);
2936
2937
2938
2939
2940
2941
2942
2943void snd_hda_codec_resume_cache(struct hda_codec *codec)
2944{
2945 struct hda_cache_head *buffer = codec->cmd_cache.buf.list;
2946 int i;
2947
2948 for (i = 0; i < codec->cmd_cache.buf.used; i++, buffer++) {
2949 u32 key = buffer->key;
2950 if (!key)
2951 continue;
2952 snd_hda_codec_write(codec, get_cmd_cache_nid(key), 0,
2953 get_cmd_cache_cmd(key), buffer->val);
2954 }
2955}
2956EXPORT_SYMBOL_HDA(snd_hda_codec_resume_cache);
2957
2958
2959
2960
2961
2962
2963
2964
2965
2966
2967void snd_hda_sequence_write_cache(struct hda_codec *codec,
2968 const struct hda_verb *seq)
2969{
2970 for (; seq->nid; seq++)
2971 snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb,
2972 seq->param);
2973}
2974EXPORT_SYMBOL_HDA(snd_hda_sequence_write_cache);
2975#endif
2976
2977
2978
2979
2980static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
2981 unsigned int power_state)
2982{
2983 hda_nid_t nid;
2984 int i;
2985
2986
2987 if (power_state == AC_PWRST_D3)
2988 msleep(100);
2989 snd_hda_codec_read(codec, fg, 0, AC_VERB_SET_POWER_STATE,
2990 power_state);
2991
2992 if (power_state == AC_PWRST_D0 &&
2993 (codec->vendor_id & 0xffff0000) == 0x14f10000)
2994 msleep(10);
2995
2996 nid = codec->start_nid;
2997 for (i = 0; i < codec->num_nodes; i++, nid++) {
2998 unsigned int wcaps = get_wcaps(codec, nid);
2999 if (wcaps & AC_WCAP_POWER) {
3000 unsigned int wid_type = get_wcaps_type(wcaps);
3001 if (power_state == AC_PWRST_D3 &&
3002 wid_type == AC_WID_PIN) {
3003 unsigned int pincap;
3004
3005
3006
3007
3008 pincap = snd_hda_query_pin_caps(codec, nid);
3009 if (pincap & AC_PINCAP_EAPD) {
3010 int eapd = snd_hda_codec_read(codec,
3011 nid, 0,
3012 AC_VERB_GET_EAPD_BTLENABLE, 0);
3013 eapd &= 0x02;
3014 if (eapd)
3015 continue;
3016 }
3017 }
3018 snd_hda_codec_write(codec, nid, 0,
3019 AC_VERB_SET_POWER_STATE,
3020 power_state);
3021 }
3022 }
3023
3024 if (power_state == AC_PWRST_D0) {
3025 unsigned long end_time;
3026 int state;
3027
3028 end_time = jiffies + msecs_to_jiffies(500);
3029 do {
3030 state = snd_hda_codec_read(codec, fg, 0,
3031 AC_VERB_GET_POWER_STATE, 0);
3032 if (state == power_state)
3033 break;
3034 msleep(1);
3035 } while (time_after_eq(end_time, jiffies));
3036 }
3037}
3038
3039#ifdef CONFIG_SND_HDA_HWDEP
3040
3041static void hda_exec_init_verbs(struct hda_codec *codec)
3042{
3043 if (codec->init_verbs.list)
3044 snd_hda_sequence_write(codec, codec->init_verbs.list);
3045}
3046#else
3047static inline void hda_exec_init_verbs(struct hda_codec *codec) {}
3048#endif
3049
3050#ifdef SND_HDA_NEEDS_RESUME
3051
3052
3053
3054static void hda_call_codec_suspend(struct hda_codec *codec)
3055{
3056 if (codec->patch_ops.suspend)
3057 codec->patch_ops.suspend(codec, PMSG_SUSPEND);
3058 hda_cleanup_all_streams(codec);
3059 hda_set_power_state(codec,
3060 codec->afg ? codec->afg : codec->mfg,
3061 AC_PWRST_D3);
3062#ifdef CONFIG_SND_HDA_POWER_SAVE
3063 snd_hda_update_power_acct(codec);
3064 cancel_delayed_work(&codec->power_work);
3065 codec->power_on = 0;
3066 codec->power_transition = 0;
3067 codec->power_jiffies = jiffies;
3068#endif
3069}
3070
3071
3072
3073
3074static void hda_call_codec_resume(struct hda_codec *codec)
3075{
3076 hda_set_power_state(codec,
3077 codec->afg ? codec->afg : codec->mfg,
3078 AC_PWRST_D0);
3079 restore_pincfgs(codec);
3080 restore_shutup_pins(codec);
3081 hda_exec_init_verbs(codec);
3082 if (codec->patch_ops.resume)
3083 codec->patch_ops.resume(codec);
3084 else {
3085 if (codec->patch_ops.init)
3086 codec->patch_ops.init(codec);
3087 snd_hda_codec_resume_amp(codec);
3088 snd_hda_codec_resume_cache(codec);
3089 }
3090}
3091#endif
3092
3093
3094
3095
3096
3097
3098
3099
3100
3101
3102int snd_hda_build_controls(struct hda_bus *bus)
3103{
3104 struct hda_codec *codec;
3105
3106 list_for_each_entry(codec, &bus->codec_list, list) {
3107 int err = snd_hda_codec_build_controls(codec);
3108 if (err < 0) {
3109 printk(KERN_ERR "hda_codec: cannot build controls "
3110 "for #%d (error %d)\n", codec->addr, err);
3111 err = snd_hda_codec_reset(codec);
3112 if (err < 0) {
3113 printk(KERN_ERR
3114 "hda_codec: cannot revert codec\n");
3115 return err;
3116 }
3117 }
3118 }
3119 return 0;
3120}
3121EXPORT_SYMBOL_HDA(snd_hda_build_controls);
3122
3123int snd_hda_codec_build_controls(struct hda_codec *codec)
3124{
3125 int err = 0;
3126 hda_exec_init_verbs(codec);
3127
3128 if (codec->patch_ops.init)
3129 err = codec->patch_ops.init(codec);
3130 if (!err && codec->patch_ops.build_controls)
3131 err = codec->patch_ops.build_controls(codec);
3132 if (err < 0)
3133 return err;
3134 return 0;
3135}
3136
3137
3138
3139
3140struct hda_rate_tbl {
3141 unsigned int hz;
3142 unsigned int alsa_bits;
3143 unsigned int hda_fmt;
3144};
3145
3146
3147#define HDA_RATE(base, mult, div) \
3148 (AC_FMT_BASE_##base##K | (((mult) - 1) << AC_FMT_MULT_SHIFT) | \
3149 (((div) - 1) << AC_FMT_DIV_SHIFT))
3150
3151static struct hda_rate_tbl rate_bits[] = {
3152
3153
3154
3155 { 8000, SNDRV_PCM_RATE_8000, HDA_RATE(48, 1, 6) },
3156 { 11025, SNDRV_PCM_RATE_11025, HDA_RATE(44, 1, 4) },
3157 { 16000, SNDRV_PCM_RATE_16000, HDA_RATE(48, 1, 3) },
3158 { 22050, SNDRV_PCM_RATE_22050, HDA_RATE(44, 1, 2) },
3159 { 32000, SNDRV_PCM_RATE_32000, HDA_RATE(48, 2, 3) },
3160 { 44100, SNDRV_PCM_RATE_44100, HDA_RATE(44, 1, 1) },
3161 { 48000, SNDRV_PCM_RATE_48000, HDA_RATE(48, 1, 1) },
3162 { 88200, SNDRV_PCM_RATE_88200, HDA_RATE(44, 2, 1) },
3163 { 96000, SNDRV_PCM_RATE_96000, HDA_RATE(48, 2, 1) },
3164 { 176400, SNDRV_PCM_RATE_176400, HDA_RATE(44, 4, 1) },
3165 { 192000, SNDRV_PCM_RATE_192000, HDA_RATE(48, 4, 1) },
3166#define AC_PAR_PCM_RATE_BITS 11
3167
3168
3169
3170 { 9600, SNDRV_PCM_RATE_KNOT, HDA_RATE(48, 1, 5) },
3171
3172 { 0 }
3173};
3174
3175
3176
3177
3178
3179
3180
3181
3182
3183
3184
3185
3186unsigned int snd_hda_calc_stream_format(unsigned int rate,
3187 unsigned int channels,
3188 unsigned int format,
3189 unsigned int maxbps,
3190 unsigned short spdif_ctls)
3191{
3192 int i;
3193 unsigned int val = 0;
3194
3195 for (i = 0; rate_bits[i].hz; i++)
3196 if (rate_bits[i].hz == rate) {
3197 val = rate_bits[i].hda_fmt;
3198 break;
3199 }
3200 if (!rate_bits[i].hz) {
3201 snd_printdd("invalid rate %d\n", rate);
3202 return 0;
3203 }
3204
3205 if (channels == 0 || channels > 8) {
3206 snd_printdd("invalid channels %d\n", channels);
3207 return 0;
3208 }
3209 val |= channels - 1;
3210
3211 switch (snd_pcm_format_width(format)) {
3212 case 8:
3213 val |= AC_FMT_BITS_8;
3214 break;
3215 case 16:
3216 val |= AC_FMT_BITS_16;
3217 break;
3218 case 20:
3219 case 24:
3220 case 32:
3221 if (maxbps >= 32 || format == SNDRV_PCM_FORMAT_FLOAT_LE)
3222 val |= AC_FMT_BITS_32;
3223 else if (maxbps >= 24)
3224 val |= AC_FMT_BITS_24;
3225 else
3226 val |= AC_FMT_BITS_20;
3227 break;
3228 default:
3229 snd_printdd("invalid format width %d\n",
3230 snd_pcm_format_width(format));
3231 return 0;
3232 }
3233
3234 if (spdif_ctls & AC_DIG1_NONAUDIO)
3235 val |= AC_FMT_TYPE_NON_PCM;
3236
3237 return val;
3238}
3239EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format);
3240
3241static unsigned int get_pcm_param(struct hda_codec *codec, hda_nid_t nid)
3242{
3243 unsigned int val = 0;
3244 if (nid != codec->afg &&
3245 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD))
3246 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
3247 if (!val || val == -1)
3248 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
3249 if (!val || val == -1)
3250 return 0;
3251 return val;
3252}
3253
3254static unsigned int query_pcm_param(struct hda_codec *codec, hda_nid_t nid)
3255{
3256 return query_caps_hash(codec, nid, HDA_HASH_PARPCM_KEY(nid),
3257 get_pcm_param);
3258}
3259
3260static unsigned int get_stream_param(struct hda_codec *codec, hda_nid_t nid)
3261{
3262 unsigned int streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
3263 if (!streams || streams == -1)
3264 streams = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM);
3265 if (!streams || streams == -1)
3266 return 0;
3267 return streams;
3268}
3269
3270static unsigned int query_stream_param(struct hda_codec *codec, hda_nid_t nid)
3271{
3272 return query_caps_hash(codec, nid, HDA_HASH_PARSTR_KEY(nid),
3273 get_stream_param);
3274}
3275
3276
3277
3278
3279
3280
3281
3282
3283
3284
3285
3286
3287
3288
3289static int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
3290 u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
3291{
3292 unsigned int i, val, wcaps;
3293
3294 wcaps = get_wcaps(codec, nid);
3295 val = query_pcm_param(codec, nid);
3296
3297 if (ratesp) {
3298 u32 rates = 0;
3299 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) {
3300 if (val & (1 << i))
3301 rates |= rate_bits[i].alsa_bits;
3302 }
3303 if (rates == 0) {
3304 snd_printk(KERN_ERR "hda_codec: rates == 0 "
3305 "(nid=0x%x, val=0x%x, ovrd=%i)\n",
3306 nid, val,
3307 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0);
3308 return -EIO;
3309 }
3310 *ratesp = rates;
3311 }
3312
3313 if (formatsp || bpsp) {
3314 u64 formats = 0;
3315 unsigned int streams, bps;
3316
3317 streams = query_stream_param(codec, nid);
3318 if (!streams)
3319 return -EIO;
3320
3321 bps = 0;
3322 if (streams & AC_SUPFMT_PCM) {
3323 if (val & AC_SUPPCM_BITS_8) {
3324 formats |= SNDRV_PCM_FMTBIT_U8;
3325 bps = 8;
3326 }
3327 if (val & AC_SUPPCM_BITS_16) {
3328 formats |= SNDRV_PCM_FMTBIT_S16_LE;
3329 bps = 16;
3330 }
3331 if (wcaps & AC_WCAP_DIGITAL) {
3332 if (val & AC_SUPPCM_BITS_32)
3333 formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE;
3334 if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24))
3335 formats |= SNDRV_PCM_FMTBIT_S32_LE;
3336 if (val & AC_SUPPCM_BITS_24)
3337 bps = 24;
3338 else if (val & AC_SUPPCM_BITS_20)
3339 bps = 20;
3340 } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24|
3341 AC_SUPPCM_BITS_32)) {
3342 formats |= SNDRV_PCM_FMTBIT_S32_LE;
3343 if (val & AC_SUPPCM_BITS_32)
3344 bps = 32;
3345 else if (val & AC_SUPPCM_BITS_24)
3346 bps = 24;
3347 else if (val & AC_SUPPCM_BITS_20)
3348 bps = 20;
3349 }
3350 }
3351 if (streams & AC_SUPFMT_FLOAT32) {
3352 formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
3353 if (!bps)
3354 bps = 32;
3355 }
3356 if (streams == AC_SUPFMT_AC3) {
3357
3358
3359
3360
3361 formats |= SNDRV_PCM_FMTBIT_U8;
3362 bps = 8;
3363 }
3364 if (formats == 0) {
3365 snd_printk(KERN_ERR "hda_codec: formats == 0 "
3366 "(nid=0x%x, val=0x%x, ovrd=%i, "
3367 "streams=0x%x)\n",
3368 nid, val,
3369 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0,
3370 streams);
3371 return -EIO;
3372 }
3373 if (formatsp)
3374 *formatsp = formats;
3375 if (bpsp)
3376 *bpsp = bps;
3377 }
3378
3379 return 0;
3380}
3381
3382
3383
3384
3385
3386
3387
3388
3389
3390
3391
3392int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
3393 unsigned int format)
3394{
3395 int i;
3396 unsigned int val = 0, rate, stream;
3397
3398 val = query_pcm_param(codec, nid);
3399 if (!val)
3400 return 0;
3401
3402 rate = format & 0xff00;
3403 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++)
3404 if (rate_bits[i].hda_fmt == rate) {
3405 if (val & (1 << i))
3406 break;
3407 return 0;
3408 }
3409 if (i >= AC_PAR_PCM_RATE_BITS)
3410 return 0;
3411
3412 stream = query_stream_param(codec, nid);
3413 if (!stream)
3414 return 0;
3415
3416 if (stream & AC_SUPFMT_PCM) {
3417 switch (format & 0xf0) {
3418 case 0x00:
3419 if (!(val & AC_SUPPCM_BITS_8))
3420 return 0;
3421 break;
3422 case 0x10:
3423 if (!(val & AC_SUPPCM_BITS_16))
3424 return 0;
3425 break;
3426 case 0x20:
3427 if (!(val & AC_SUPPCM_BITS_20))
3428 return 0;
3429 break;
3430 case 0x30:
3431 if (!(val & AC_SUPPCM_BITS_24))
3432 return 0;
3433 break;
3434 case 0x40:
3435 if (!(val & AC_SUPPCM_BITS_32))
3436 return 0;
3437 break;
3438 default:
3439 return 0;
3440 }
3441 } else {
3442
3443 }
3444
3445 return 1;
3446}
3447EXPORT_SYMBOL_HDA(snd_hda_is_supported_format);
3448
3449
3450
3451
3452static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo,
3453 struct hda_codec *codec,
3454 struct snd_pcm_substream *substream)
3455{
3456 return 0;
3457}
3458
3459static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo,
3460 struct hda_codec *codec,
3461 unsigned int stream_tag,
3462 unsigned int format,
3463 struct snd_pcm_substream *substream)
3464{
3465 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
3466 return 0;
3467}
3468
3469static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
3470 struct hda_codec *codec,
3471 struct snd_pcm_substream *substream)
3472{
3473 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
3474 return 0;
3475}
3476
3477static int set_pcm_default_values(struct hda_codec *codec,
3478 struct hda_pcm_stream *info)
3479{
3480 int err;
3481
3482
3483 if (info->nid && (!info->rates || !info->formats)) {
3484 err = snd_hda_query_supported_pcm(codec, info->nid,
3485 info->rates ? NULL : &info->rates,
3486 info->formats ? NULL : &info->formats,
3487 info->maxbps ? NULL : &info->maxbps);
3488 if (err < 0)
3489 return err;
3490 }
3491 if (info->ops.open == NULL)
3492 info->ops.open = hda_pcm_default_open_close;
3493 if (info->ops.close == NULL)
3494 info->ops.close = hda_pcm_default_open_close;
3495 if (info->ops.prepare == NULL) {
3496 if (snd_BUG_ON(!info->nid))
3497 return -EINVAL;
3498 info->ops.prepare = hda_pcm_default_prepare;
3499 }
3500 if (info->ops.cleanup == NULL) {
3501 if (snd_BUG_ON(!info->nid))
3502 return -EINVAL;
3503 info->ops.cleanup = hda_pcm_default_cleanup;
3504 }
3505 return 0;
3506}
3507
3508
3509
3510
3511int snd_hda_codec_prepare(struct hda_codec *codec,
3512 struct hda_pcm_stream *hinfo,
3513 unsigned int stream,
3514 unsigned int format,
3515 struct snd_pcm_substream *substream)
3516{
3517 int ret;
3518 mutex_lock(&codec->bus->prepare_mutex);
3519 ret = hinfo->ops.prepare(hinfo, codec, stream, format, substream);
3520 if (ret >= 0)
3521 purify_inactive_streams(codec);
3522 mutex_unlock(&codec->bus->prepare_mutex);
3523 return ret;
3524}
3525EXPORT_SYMBOL_HDA(snd_hda_codec_prepare);
3526
3527void snd_hda_codec_cleanup(struct hda_codec *codec,
3528 struct hda_pcm_stream *hinfo,
3529 struct snd_pcm_substream *substream)
3530{
3531 mutex_lock(&codec->bus->prepare_mutex);
3532 hinfo->ops.cleanup(hinfo, codec, substream);
3533 mutex_unlock(&codec->bus->prepare_mutex);
3534}
3535EXPORT_SYMBOL_HDA(snd_hda_codec_cleanup);
3536
3537
3538const char *snd_hda_pcm_type_name[HDA_PCM_NTYPES] = {
3539 "Audio", "SPDIF", "HDMI", "Modem"
3540};
3541
3542
3543
3544
3545
3546
3547static int get_empty_pcm_device(struct hda_bus *bus, int type)
3548{
3549
3550 static int audio_idx[HDA_PCM_NTYPES][5] = {
3551 [HDA_PCM_TYPE_AUDIO] = { 0, 2, 4, 5, -1 },
3552 [HDA_PCM_TYPE_SPDIF] = { 1, -1 },
3553 [HDA_PCM_TYPE_HDMI] = { 3, 7, 8, 9, -1 },
3554 [HDA_PCM_TYPE_MODEM] = { 6, -1 },
3555 };
3556 int i;
3557
3558 if (type >= HDA_PCM_NTYPES) {
3559 snd_printk(KERN_WARNING "Invalid PCM type %d\n", type);
3560 return -EINVAL;
3561 }
3562
3563 for (i = 0; audio_idx[type][i] >= 0 ; i++)
3564 if (!test_and_set_bit(audio_idx[type][i], bus->pcm_dev_bits))
3565 return audio_idx[type][i];
3566
3567 snd_printk(KERN_WARNING "Too many %s devices\n",
3568 snd_hda_pcm_type_name[type]);
3569 return -EAGAIN;
3570}
3571
3572
3573
3574
3575static int snd_hda_attach_pcm(struct hda_codec *codec, struct hda_pcm *pcm)
3576{
3577 struct hda_bus *bus = codec->bus;
3578 struct hda_pcm_stream *info;
3579 int stream, err;
3580
3581 if (snd_BUG_ON(!pcm->name))
3582 return -EINVAL;
3583 for (stream = 0; stream < 2; stream++) {
3584 info = &pcm->stream[stream];
3585 if (info->substreams) {
3586 err = set_pcm_default_values(codec, info);
3587 if (err < 0)
3588 return err;
3589 }
3590 }
3591 return bus->ops.attach_pcm(bus, codec, pcm);
3592}
3593
3594
3595int snd_hda_codec_build_pcms(struct hda_codec *codec)
3596{
3597 unsigned int pcm;
3598 int err;
3599
3600 if (!codec->num_pcms) {
3601 if (!codec->patch_ops.build_pcms)
3602 return 0;
3603 err = codec->patch_ops.build_pcms(codec);
3604 if (err < 0) {
3605 printk(KERN_ERR "hda_codec: cannot build PCMs"
3606 "for #%d (error %d)\n", codec->addr, err);
3607 err = snd_hda_codec_reset(codec);
3608 if (err < 0) {
3609 printk(KERN_ERR
3610 "hda_codec: cannot revert codec\n");
3611 return err;
3612 }
3613 }
3614 }
3615 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
3616 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
3617 int dev;
3618
3619 if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)
3620 continue;
3621
3622 if (!cpcm->pcm) {
3623 dev = get_empty_pcm_device(codec->bus, cpcm->pcm_type);
3624 if (dev < 0)
3625 continue;
3626 cpcm->device = dev;
3627 err = snd_hda_attach_pcm(codec, cpcm);
3628 if (err < 0) {
3629 printk(KERN_ERR "hda_codec: cannot attach "
3630 "PCM stream %d for codec #%d\n",
3631 dev, codec->addr);
3632 continue;
3633 }
3634 }
3635 }
3636 return 0;
3637}
3638
3639
3640
3641
3642
3643
3644
3645
3646
3647
3648
3649
3650
3651
3652
3653
3654
3655
3656
3657
3658
3659
3660
3661
3662
3663
3664
3665int __devinit snd_hda_build_pcms(struct hda_bus *bus)
3666{
3667 struct hda_codec *codec;
3668
3669 list_for_each_entry(codec, &bus->codec_list, list) {
3670 int err = snd_hda_codec_build_pcms(codec);
3671 if (err < 0)
3672 return err;
3673 }
3674 return 0;
3675}
3676EXPORT_SYMBOL_HDA(snd_hda_build_pcms);
3677
3678
3679
3680
3681
3682
3683
3684
3685
3686
3687
3688
3689
3690
3691int snd_hda_check_board_config(struct hda_codec *codec,
3692 int num_configs, const char * const *models,
3693 const struct snd_pci_quirk *tbl)
3694{
3695 if (codec->modelname && models) {
3696 int i;
3697 for (i = 0; i < num_configs; i++) {
3698 if (models[i] &&
3699 !strcmp(codec->modelname, models[i])) {
3700 snd_printd(KERN_INFO "hda_codec: model '%s' is "
3701 "selected\n", models[i]);
3702 return i;
3703 }
3704 }
3705 }
3706
3707 if (!codec->bus->pci || !tbl)
3708 return -1;
3709
3710 tbl = snd_pci_quirk_lookup(codec->bus->pci, tbl);
3711 if (!tbl)
3712 return -1;
3713 if (tbl->value >= 0 && tbl->value < num_configs) {
3714#ifdef CONFIG_SND_DEBUG_VERBOSE
3715 char tmp[10];
3716 const char *model = NULL;
3717 if (models)
3718 model = models[tbl->value];
3719 if (!model) {
3720 sprintf(tmp, "#%d", tbl->value);
3721 model = tmp;
3722 }
3723 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
3724 "for config %x:%x (%s)\n",
3725 model, tbl->subvendor, tbl->subdevice,
3726 (tbl->name ? tbl->name : "Unknown device"));
3727#endif
3728 return tbl->value;
3729 }
3730 return -1;
3731}
3732EXPORT_SYMBOL_HDA(snd_hda_check_board_config);
3733
3734
3735
3736
3737
3738
3739
3740
3741
3742
3743
3744
3745
3746
3747
3748
3749
3750
3751
3752
3753
3754
3755int snd_hda_check_board_codec_sid_config(struct hda_codec *codec,
3756 int num_configs, const char * const *models,
3757 const struct snd_pci_quirk *tbl)
3758{
3759 const struct snd_pci_quirk *q;
3760
3761
3762 for (q = tbl; q->subvendor; q++) {
3763 unsigned long vendorid = (q->subdevice) | (q->subvendor << 16);
3764
3765 if (vendorid == codec->subsystem_id)
3766 break;
3767 }
3768
3769 if (!q->subvendor)
3770 return -1;
3771
3772 tbl = q;
3773
3774 if (tbl->value >= 0 && tbl->value < num_configs) {
3775#ifdef CONFIG_SND_DEBUG_VERBOSE
3776 char tmp[10];
3777 const char *model = NULL;
3778 if (models)
3779 model = models[tbl->value];
3780 if (!model) {
3781 sprintf(tmp, "#%d", tbl->value);
3782 model = tmp;
3783 }
3784 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
3785 "for config %x:%x (%s)\n",
3786 model, tbl->subvendor, tbl->subdevice,
3787 (tbl->name ? tbl->name : "Unknown device"));
3788#endif
3789 return tbl->value;
3790 }
3791 return -1;
3792}
3793EXPORT_SYMBOL_HDA(snd_hda_check_board_codec_sid_config);
3794
3795
3796
3797
3798
3799
3800
3801
3802
3803
3804
3805int snd_hda_add_new_ctls(struct hda_codec *codec, struct snd_kcontrol_new *knew)
3806{
3807 int err;
3808
3809 for (; knew->name; knew++) {
3810 struct snd_kcontrol *kctl;
3811 int addr = 0, idx = 0;
3812 if (knew->iface == -1)
3813 continue;
3814 for (;;) {
3815 kctl = snd_ctl_new1(knew, codec);
3816 if (!kctl)
3817 return -ENOMEM;
3818 if (addr > 0)
3819 kctl->id.device = addr;
3820 if (idx > 0)
3821 kctl->id.index = idx;
3822 err = snd_hda_ctl_add(codec, 0, kctl);
3823 if (!err)
3824 break;
3825
3826
3827
3828
3829 if (!addr && codec->addr)
3830 addr = codec->addr;
3831 else if (!idx && !knew->index) {
3832 idx = find_empty_mixer_ctl_idx(codec,
3833 knew->name);
3834 if (idx <= 0)
3835 return err;
3836 } else
3837 return err;
3838 }
3839 }
3840 return 0;
3841}
3842EXPORT_SYMBOL_HDA(snd_hda_add_new_ctls);
3843
3844#ifdef CONFIG_SND_HDA_POWER_SAVE
3845static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
3846 unsigned int power_state);
3847
3848static void hda_power_work(struct work_struct *work)
3849{
3850 struct hda_codec *codec =
3851 container_of(work, struct hda_codec, power_work.work);
3852 struct hda_bus *bus = codec->bus;
3853
3854 if (!codec->power_on || codec->power_count) {
3855 codec->power_transition = 0;
3856 return;
3857 }
3858
3859 hda_call_codec_suspend(codec);
3860 if (bus->ops.pm_notify)
3861 bus->ops.pm_notify(bus);
3862}
3863
3864static void hda_keep_power_on(struct hda_codec *codec)
3865{
3866 codec->power_count++;
3867 codec->power_on = 1;
3868 codec->power_jiffies = jiffies;
3869}
3870
3871
3872void snd_hda_update_power_acct(struct hda_codec *codec)
3873{
3874 unsigned long delta = jiffies - codec->power_jiffies;
3875 if (codec->power_on)
3876 codec->power_on_acct += delta;
3877 else
3878 codec->power_off_acct += delta;
3879 codec->power_jiffies += delta;
3880}
3881
3882
3883
3884
3885
3886
3887
3888
3889void snd_hda_power_up(struct hda_codec *codec)
3890{
3891 struct hda_bus *bus = codec->bus;
3892
3893 codec->power_count++;
3894 if (codec->power_on || codec->power_transition)
3895 return;
3896
3897 snd_hda_update_power_acct(codec);
3898 codec->power_on = 1;
3899 codec->power_jiffies = jiffies;
3900 if (bus->ops.pm_notify)
3901 bus->ops.pm_notify(bus);
3902 hda_call_codec_resume(codec);
3903 cancel_delayed_work(&codec->power_work);
3904 codec->power_transition = 0;
3905}
3906EXPORT_SYMBOL_HDA(snd_hda_power_up);
3907
3908#define power_save(codec) \
3909 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
3910
3911
3912
3913
3914
3915
3916
3917
3918void snd_hda_power_down(struct hda_codec *codec)
3919{
3920 --codec->power_count;
3921 if (!codec->power_on || codec->power_count || codec->power_transition)
3922 return;
3923 if (power_save(codec)) {
3924 codec->power_transition = 1;
3925 queue_delayed_work(codec->bus->workq, &codec->power_work,
3926 msecs_to_jiffies(power_save(codec) * 1000));
3927 }
3928}
3929EXPORT_SYMBOL_HDA(snd_hda_power_down);
3930
3931
3932
3933
3934
3935
3936
3937
3938
3939
3940
3941
3942
3943
3944int snd_hda_check_amp_list_power(struct hda_codec *codec,
3945 struct hda_loopback_check *check,
3946 hda_nid_t nid)
3947{
3948 struct hda_amp_list *p;
3949 int ch, v;
3950
3951 if (!check->amplist)
3952 return 0;
3953 for (p = check->amplist; p->nid; p++) {
3954 if (p->nid == nid)
3955 break;
3956 }
3957 if (!p->nid)
3958 return 0;
3959
3960 for (p = check->amplist; p->nid; p++) {
3961 for (ch = 0; ch < 2; ch++) {
3962 v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
3963 p->idx);
3964 if (!(v & HDA_AMP_MUTE) && v > 0) {
3965 if (!check->power_on) {
3966 check->power_on = 1;
3967 snd_hda_power_up(codec);
3968 }
3969 return 1;
3970 }
3971 }
3972 }
3973 if (check->power_on) {
3974 check->power_on = 0;
3975 snd_hda_power_down(codec);
3976 }
3977 return 0;
3978}
3979EXPORT_SYMBOL_HDA(snd_hda_check_amp_list_power);
3980#endif
3981
3982
3983
3984
3985
3986
3987
3988
3989int snd_hda_ch_mode_info(struct hda_codec *codec,
3990 struct snd_ctl_elem_info *uinfo,
3991 const struct hda_channel_mode *chmode,
3992 int num_chmodes)
3993{
3994 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3995 uinfo->count = 1;
3996 uinfo->value.enumerated.items = num_chmodes;
3997 if (uinfo->value.enumerated.item >= num_chmodes)
3998 uinfo->value.enumerated.item = num_chmodes - 1;
3999 sprintf(uinfo->value.enumerated.name, "%dch",
4000 chmode[uinfo->value.enumerated.item].channels);
4001 return 0;
4002}
4003EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info);
4004
4005
4006
4007
4008int snd_hda_ch_mode_get(struct hda_codec *codec,
4009 struct snd_ctl_elem_value *ucontrol,
4010 const struct hda_channel_mode *chmode,
4011 int num_chmodes,
4012 int max_channels)
4013{
4014 int i;
4015
4016 for (i = 0; i < num_chmodes; i++) {
4017 if (max_channels == chmode[i].channels) {
4018 ucontrol->value.enumerated.item[0] = i;
4019 break;
4020 }
4021 }
4022 return 0;
4023}
4024EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get);
4025
4026
4027
4028
4029int snd_hda_ch_mode_put(struct hda_codec *codec,
4030 struct snd_ctl_elem_value *ucontrol,
4031 const struct hda_channel_mode *chmode,
4032 int num_chmodes,
4033 int *max_channelsp)
4034{
4035 unsigned int mode;
4036
4037 mode = ucontrol->value.enumerated.item[0];
4038 if (mode >= num_chmodes)
4039 return -EINVAL;
4040 if (*max_channelsp == chmode[mode].channels)
4041 return 0;
4042
4043 *max_channelsp = chmode[mode].channels;
4044 if (chmode[mode].sequence)
4045 snd_hda_sequence_write_cache(codec, chmode[mode].sequence);
4046 return 1;
4047}
4048EXPORT_SYMBOL_HDA(snd_hda_ch_mode_put);
4049
4050
4051
4052
4053
4054
4055
4056
4057int snd_hda_input_mux_info(const struct hda_input_mux *imux,
4058 struct snd_ctl_elem_info *uinfo)
4059{
4060 unsigned int index;
4061
4062 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
4063 uinfo->count = 1;
4064 uinfo->value.enumerated.items = imux->num_items;
4065 if (!imux->num_items)
4066 return 0;
4067 index = uinfo->value.enumerated.item;
4068 if (index >= imux->num_items)
4069 index = imux->num_items - 1;
4070 strcpy(uinfo->value.enumerated.name, imux->items[index].label);
4071 return 0;
4072}
4073EXPORT_SYMBOL_HDA(snd_hda_input_mux_info);
4074
4075
4076
4077
4078int snd_hda_input_mux_put(struct hda_codec *codec,
4079 const struct hda_input_mux *imux,
4080 struct snd_ctl_elem_value *ucontrol,
4081 hda_nid_t nid,
4082 unsigned int *cur_val)
4083{
4084 unsigned int idx;
4085
4086 if (!imux->num_items)
4087 return 0;
4088 idx = ucontrol->value.enumerated.item[0];
4089 if (idx >= imux->num_items)
4090 idx = imux->num_items - 1;
4091 if (*cur_val == idx)
4092 return 0;
4093 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
4094 imux->items[idx].index);
4095 *cur_val = idx;
4096 return 1;
4097}
4098EXPORT_SYMBOL_HDA(snd_hda_input_mux_put);
4099
4100
4101
4102
4103
4104
4105
4106static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
4107 unsigned int stream_tag, unsigned int format)
4108{
4109
4110 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
4111 set_dig_out_convert(codec, nid,
4112 codec->spdif_ctls & ~AC_DIG1_ENABLE & 0xff,
4113 -1);
4114 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
4115 if (codec->slave_dig_outs) {
4116 hda_nid_t *d;
4117 for (d = codec->slave_dig_outs; *d; d++)
4118 snd_hda_codec_setup_stream(codec, *d, stream_tag, 0,
4119 format);
4120 }
4121
4122 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
4123 set_dig_out_convert(codec, nid,
4124 codec->spdif_ctls & 0xff, -1);
4125}
4126
4127static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
4128{
4129 snd_hda_codec_cleanup_stream(codec, nid);
4130 if (codec->slave_dig_outs) {
4131 hda_nid_t *d;
4132 for (d = codec->slave_dig_outs; *d; d++)
4133 snd_hda_codec_cleanup_stream(codec, *d);
4134 }
4135}
4136
4137
4138
4139
4140
4141void snd_hda_bus_reboot_notify(struct hda_bus *bus)
4142{
4143 struct hda_codec *codec;
4144
4145 if (!bus)
4146 return;
4147 list_for_each_entry(codec, &bus->codec_list, list) {
4148#ifdef CONFIG_SND_HDA_POWER_SAVE
4149 if (!codec->power_on)
4150 continue;
4151#endif
4152 if (codec->patch_ops.reboot_notify)
4153 codec->patch_ops.reboot_notify(codec);
4154 }
4155}
4156EXPORT_SYMBOL_HDA(snd_hda_bus_reboot_notify);
4157
4158
4159
4160
4161int snd_hda_multi_out_dig_open(struct hda_codec *codec,
4162 struct hda_multi_out *mout)
4163{
4164 mutex_lock(&codec->spdif_mutex);
4165 if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
4166
4167 cleanup_dig_out_stream(codec, mout->dig_out_nid);
4168 mout->dig_out_used = HDA_DIG_EXCLUSIVE;
4169 mutex_unlock(&codec->spdif_mutex);
4170 return 0;
4171}
4172EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_open);
4173
4174
4175
4176
4177int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
4178 struct hda_multi_out *mout,
4179 unsigned int stream_tag,
4180 unsigned int format,
4181 struct snd_pcm_substream *substream)
4182{
4183 mutex_lock(&codec->spdif_mutex);
4184 setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
4185 mutex_unlock(&codec->spdif_mutex);
4186 return 0;
4187}
4188EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare);
4189
4190
4191
4192
4193int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec,
4194 struct hda_multi_out *mout)
4195{
4196 mutex_lock(&codec->spdif_mutex);
4197 cleanup_dig_out_stream(codec, mout->dig_out_nid);
4198 mutex_unlock(&codec->spdif_mutex);
4199 return 0;
4200}
4201EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_cleanup);
4202
4203
4204
4205
4206int snd_hda_multi_out_dig_close(struct hda_codec *codec,
4207 struct hda_multi_out *mout)
4208{
4209 mutex_lock(&codec->spdif_mutex);
4210 mout->dig_out_used = 0;
4211 mutex_unlock(&codec->spdif_mutex);
4212 return 0;
4213}
4214EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_close);
4215
4216
4217
4218
4219
4220
4221
4222
4223int snd_hda_multi_out_analog_open(struct hda_codec *codec,
4224 struct hda_multi_out *mout,
4225 struct snd_pcm_substream *substream,
4226 struct hda_pcm_stream *hinfo)
4227{
4228 struct snd_pcm_runtime *runtime = substream->runtime;
4229 runtime->hw.channels_max = mout->max_channels;
4230 if (mout->dig_out_nid) {
4231 if (!mout->analog_rates) {
4232 mout->analog_rates = hinfo->rates;
4233 mout->analog_formats = hinfo->formats;
4234 mout->analog_maxbps = hinfo->maxbps;
4235 } else {
4236 runtime->hw.rates = mout->analog_rates;
4237 runtime->hw.formats = mout->analog_formats;
4238 hinfo->maxbps = mout->analog_maxbps;
4239 }
4240 if (!mout->spdif_rates) {
4241 snd_hda_query_supported_pcm(codec, mout->dig_out_nid,
4242 &mout->spdif_rates,
4243 &mout->spdif_formats,
4244 &mout->spdif_maxbps);
4245 }
4246 mutex_lock(&codec->spdif_mutex);
4247 if (mout->share_spdif) {
4248 if ((runtime->hw.rates & mout->spdif_rates) &&
4249 (runtime->hw.formats & mout->spdif_formats)) {
4250 runtime->hw.rates &= mout->spdif_rates;
4251 runtime->hw.formats &= mout->spdif_formats;
4252 if (mout->spdif_maxbps < hinfo->maxbps)
4253 hinfo->maxbps = mout->spdif_maxbps;
4254 } else {
4255 mout->share_spdif = 0;
4256
4257 }
4258 }
4259 mutex_unlock(&codec->spdif_mutex);
4260 }
4261 return snd_pcm_hw_constraint_step(substream->runtime, 0,
4262 SNDRV_PCM_HW_PARAM_CHANNELS, 2);
4263}
4264EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_open);
4265
4266
4267
4268
4269
4270
4271
4272int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
4273 struct hda_multi_out *mout,
4274 unsigned int stream_tag,
4275 unsigned int format,
4276 struct snd_pcm_substream *substream)
4277{
4278 hda_nid_t *nids = mout->dac_nids;
4279 int chs = substream->runtime->channels;
4280 int i;
4281
4282 mutex_lock(&codec->spdif_mutex);
4283 if (mout->dig_out_nid && mout->share_spdif &&
4284 mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
4285 if (chs == 2 &&
4286 snd_hda_is_supported_format(codec, mout->dig_out_nid,
4287 format) &&
4288 !(codec->spdif_status & IEC958_AES0_NONAUDIO)) {
4289 mout->dig_out_used = HDA_DIG_ANALOG_DUP;
4290 setup_dig_out_stream(codec, mout->dig_out_nid,
4291 stream_tag, format);
4292 } else {
4293 mout->dig_out_used = 0;
4294 cleanup_dig_out_stream(codec, mout->dig_out_nid);
4295 }
4296 }
4297 mutex_unlock(&codec->spdif_mutex);
4298
4299
4300 snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
4301 0, format);
4302 if (!mout->no_share_stream &&
4303 mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
4304
4305 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
4306 0, format);
4307
4308 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
4309 if (!mout->no_share_stream && mout->extra_out_nid[i])
4310 snd_hda_codec_setup_stream(codec,
4311 mout->extra_out_nid[i],
4312 stream_tag, 0, format);
4313
4314
4315 for (i = 1; i < mout->num_dacs; i++) {
4316 if (chs >= (i + 1) * 2)
4317 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
4318 i * 2, format);
4319 else if (!mout->no_share_stream)
4320 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
4321 0, format);
4322 }
4323 return 0;
4324}
4325EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_prepare);
4326
4327
4328
4329
4330int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
4331 struct hda_multi_out *mout)
4332{
4333 hda_nid_t *nids = mout->dac_nids;
4334 int i;
4335
4336 for (i = 0; i < mout->num_dacs; i++)
4337 snd_hda_codec_cleanup_stream(codec, nids[i]);
4338 if (mout->hp_nid)
4339 snd_hda_codec_cleanup_stream(codec, mout->hp_nid);
4340 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
4341 if (mout->extra_out_nid[i])
4342 snd_hda_codec_cleanup_stream(codec,
4343 mout->extra_out_nid[i]);
4344 mutex_lock(&codec->spdif_mutex);
4345 if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
4346 cleanup_dig_out_stream(codec, mout->dig_out_nid);
4347 mout->dig_out_used = 0;
4348 }
4349 mutex_unlock(&codec->spdif_mutex);
4350 return 0;
4351}
4352EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_cleanup);
4353
4354
4355
4356
4357
4358static int is_in_nid_list(hda_nid_t nid, hda_nid_t *list)
4359{
4360 for (; *list; list++)
4361 if (*list == nid)
4362 return 1;
4363 return 0;
4364}
4365
4366
4367
4368
4369
4370static void sort_pins_by_sequence(hda_nid_t *pins, short *sequences,
4371 int num_pins)
4372{
4373 int i, j;
4374 short seq;
4375 hda_nid_t nid;
4376
4377 for (i = 0; i < num_pins; i++) {
4378 for (j = i + 1; j < num_pins; j++) {
4379 if (sequences[i] > sequences[j]) {
4380 seq = sequences[i];
4381 sequences[i] = sequences[j];
4382 sequences[j] = seq;
4383 nid = pins[i];
4384 pins[i] = pins[j];
4385 pins[j] = nid;
4386 }
4387 }
4388 }
4389}
4390
4391
4392
4393static void add_auto_cfg_input_pin(struct auto_pin_cfg *cfg, hda_nid_t nid,
4394 int type)
4395{
4396 if (cfg->num_inputs < AUTO_CFG_MAX_INS) {
4397 cfg->inputs[cfg->num_inputs].pin = nid;
4398 cfg->inputs[cfg->num_inputs].type = type;
4399 cfg->num_inputs++;
4400 }
4401}
4402
4403
4404static void sort_autocfg_input_pins(struct auto_pin_cfg *cfg)
4405{
4406 int i, j;
4407
4408 for (i = 0; i < cfg->num_inputs; i++) {
4409 for (j = i + 1; j < cfg->num_inputs; j++) {
4410 if (cfg->inputs[i].type > cfg->inputs[j].type) {
4411 struct auto_pin_cfg_item tmp;
4412 tmp = cfg->inputs[i];
4413 cfg->inputs[i] = cfg->inputs[j];
4414 cfg->inputs[j] = tmp;
4415 }
4416 }
4417 }
4418}
4419
4420
4421
4422
4423
4424
4425
4426
4427
4428
4429
4430
4431
4432
4433
4434
4435
4436
4437int snd_hda_parse_pin_def_config(struct hda_codec *codec,
4438 struct auto_pin_cfg *cfg,
4439 hda_nid_t *ignore_nids)
4440{
4441 hda_nid_t nid, end_nid;
4442 short seq, assoc_line_out, assoc_speaker;
4443 short sequences_line_out[ARRAY_SIZE(cfg->line_out_pins)];
4444 short sequences_speaker[ARRAY_SIZE(cfg->speaker_pins)];
4445 short sequences_hp[ARRAY_SIZE(cfg->hp_pins)];
4446 int i;
4447
4448 memset(cfg, 0, sizeof(*cfg));
4449
4450 memset(sequences_line_out, 0, sizeof(sequences_line_out));
4451 memset(sequences_speaker, 0, sizeof(sequences_speaker));
4452 memset(sequences_hp, 0, sizeof(sequences_hp));
4453 assoc_line_out = assoc_speaker = 0;
4454
4455 end_nid = codec->start_nid + codec->num_nodes;
4456 for (nid = codec->start_nid; nid < end_nid; nid++) {
4457 unsigned int wid_caps = get_wcaps(codec, nid);
4458 unsigned int wid_type = get_wcaps_type(wid_caps);
4459 unsigned int def_conf;
4460 short assoc, loc;
4461
4462
4463 if (wid_type != AC_WID_PIN)
4464 continue;
4465
4466 if (ignore_nids && is_in_nid_list(nid, ignore_nids))
4467 continue;
4468
4469 def_conf = snd_hda_codec_get_pincfg(codec, nid);
4470 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
4471 continue;
4472 loc = get_defcfg_location(def_conf);
4473 switch (get_defcfg_device(def_conf)) {
4474 case AC_JACK_LINE_OUT:
4475 seq = get_defcfg_sequence(def_conf);
4476 assoc = get_defcfg_association(def_conf);
4477
4478 if (!(wid_caps & AC_WCAP_STEREO))
4479 if (!cfg->mono_out_pin)
4480 cfg->mono_out_pin = nid;
4481 if (!assoc)
4482 continue;
4483 if (!assoc_line_out)
4484 assoc_line_out = assoc;
4485 else if (assoc_line_out != assoc)
4486 continue;
4487 if (cfg->line_outs >= ARRAY_SIZE(cfg->line_out_pins))
4488 continue;
4489 cfg->line_out_pins[cfg->line_outs] = nid;
4490 sequences_line_out[cfg->line_outs] = seq;
4491 cfg->line_outs++;
4492 break;
4493 case AC_JACK_SPEAKER:
4494 seq = get_defcfg_sequence(def_conf);
4495 assoc = get_defcfg_association(def_conf);
4496 if (!assoc)
4497 continue;
4498 if (!assoc_speaker)
4499 assoc_speaker = assoc;
4500 else if (assoc_speaker != assoc)
4501 continue;
4502 if (cfg->speaker_outs >= ARRAY_SIZE(cfg->speaker_pins))
4503 continue;
4504 cfg->speaker_pins[cfg->speaker_outs] = nid;
4505 sequences_speaker[cfg->speaker_outs] = seq;
4506 cfg->speaker_outs++;
4507 break;
4508 case AC_JACK_HP_OUT:
4509 seq = get_defcfg_sequence(def_conf);
4510 assoc = get_defcfg_association(def_conf);
4511 if (cfg->hp_outs >= ARRAY_SIZE(cfg->hp_pins))
4512 continue;
4513 cfg->hp_pins[cfg->hp_outs] = nid;
4514 sequences_hp[cfg->hp_outs] = (assoc << 4) | seq;
4515 cfg->hp_outs++;
4516 break;
4517 case AC_JACK_MIC_IN:
4518 add_auto_cfg_input_pin(cfg, nid, AUTO_PIN_MIC);
4519 break;
4520 case AC_JACK_LINE_IN:
4521 add_auto_cfg_input_pin(cfg, nid, AUTO_PIN_LINE_IN);
4522 break;
4523 case AC_JACK_CD:
4524 add_auto_cfg_input_pin(cfg, nid, AUTO_PIN_CD);
4525 break;
4526 case AC_JACK_AUX:
4527 add_auto_cfg_input_pin(cfg, nid, AUTO_PIN_AUX);
4528 break;
4529 case AC_JACK_SPDIF_OUT:
4530 case AC_JACK_DIG_OTHER_OUT:
4531 if (cfg->dig_outs >= ARRAY_SIZE(cfg->dig_out_pins))
4532 continue;
4533 cfg->dig_out_pins[cfg->dig_outs] = nid;
4534 cfg->dig_out_type[cfg->dig_outs] =
4535 (loc == AC_JACK_LOC_HDMI) ?
4536 HDA_PCM_TYPE_HDMI : HDA_PCM_TYPE_SPDIF;
4537 cfg->dig_outs++;
4538 break;
4539 case AC_JACK_SPDIF_IN:
4540 case AC_JACK_DIG_OTHER_IN:
4541 cfg->dig_in_pin = nid;
4542 if (loc == AC_JACK_LOC_HDMI)
4543 cfg->dig_in_type = HDA_PCM_TYPE_HDMI;
4544 else
4545 cfg->dig_in_type = HDA_PCM_TYPE_SPDIF;
4546 break;
4547 }
4548 }
4549
4550
4551
4552
4553
4554 if (!cfg->line_outs && cfg->hp_outs > 1) {
4555 int i = 0;
4556 while (i < cfg->hp_outs) {
4557
4558 if ((sequences_hp[i] & 0x0f) == 0x0f) {
4559 i++;
4560 continue;
4561 }
4562
4563 cfg->line_out_pins[cfg->line_outs] = cfg->hp_pins[i];
4564 sequences_line_out[cfg->line_outs] = sequences_hp[i];
4565 cfg->line_outs++;
4566 cfg->hp_outs--;
4567 memmove(cfg->hp_pins + i, cfg->hp_pins + i + 1,
4568 sizeof(cfg->hp_pins[0]) * (cfg->hp_outs - i));
4569 memmove(sequences_hp + i, sequences_hp + i + 1,
4570 sizeof(sequences_hp[0]) * (cfg->hp_outs - i));
4571 }
4572 memset(cfg->hp_pins + cfg->hp_outs, 0,
4573 sizeof(hda_nid_t) * (AUTO_CFG_MAX_OUTS - cfg->hp_outs));
4574 if (!cfg->hp_outs)
4575 cfg->line_out_type = AUTO_PIN_HP_OUT;
4576
4577 }
4578
4579
4580 sort_pins_by_sequence(cfg->line_out_pins, sequences_line_out,
4581 cfg->line_outs);
4582 sort_pins_by_sequence(cfg->speaker_pins, sequences_speaker,
4583 cfg->speaker_outs);
4584 sort_pins_by_sequence(cfg->hp_pins, sequences_hp,
4585 cfg->hp_outs);
4586
4587
4588
4589
4590
4591 if (!cfg->line_outs) {
4592 if (cfg->speaker_outs) {
4593 cfg->line_outs = cfg->speaker_outs;
4594 memcpy(cfg->line_out_pins, cfg->speaker_pins,
4595 sizeof(cfg->speaker_pins));
4596 cfg->speaker_outs = 0;
4597 memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins));
4598 cfg->line_out_type = AUTO_PIN_SPEAKER_OUT;
4599 } else if (cfg->hp_outs) {
4600 cfg->line_outs = cfg->hp_outs;
4601 memcpy(cfg->line_out_pins, cfg->hp_pins,
4602 sizeof(cfg->hp_pins));
4603 cfg->hp_outs = 0;
4604 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
4605 cfg->line_out_type = AUTO_PIN_HP_OUT;
4606 }
4607 }
4608
4609
4610
4611
4612
4613
4614
4615
4616 switch (cfg->line_outs) {
4617 case 3:
4618 case 4:
4619 nid = cfg->line_out_pins[1];
4620 cfg->line_out_pins[1] = cfg->line_out_pins[2];
4621 cfg->line_out_pins[2] = nid;
4622 break;
4623 }
4624
4625 sort_autocfg_input_pins(cfg);
4626
4627
4628
4629
4630 snd_printd("autoconfig: line_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
4631 cfg->line_outs, cfg->line_out_pins[0], cfg->line_out_pins[1],
4632 cfg->line_out_pins[2], cfg->line_out_pins[3],
4633 cfg->line_out_pins[4]);
4634 snd_printd(" speaker_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
4635 cfg->speaker_outs, cfg->speaker_pins[0],
4636 cfg->speaker_pins[1], cfg->speaker_pins[2],
4637 cfg->speaker_pins[3], cfg->speaker_pins[4]);
4638 snd_printd(" hp_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
4639 cfg->hp_outs, cfg->hp_pins[0],
4640 cfg->hp_pins[1], cfg->hp_pins[2],
4641 cfg->hp_pins[3], cfg->hp_pins[4]);
4642 snd_printd(" mono: mono_out=0x%x\n", cfg->mono_out_pin);
4643 if (cfg->dig_outs)
4644 snd_printd(" dig-out=0x%x/0x%x\n",
4645 cfg->dig_out_pins[0], cfg->dig_out_pins[1]);
4646 snd_printd(" inputs:");
4647 for (i = 0; i < cfg->num_inputs; i++) {
4648 snd_printdd(" %s=0x%x",
4649 hda_get_autocfg_input_label(codec, cfg, i),
4650 cfg->inputs[i].pin);
4651 }
4652 snd_printd("\n");
4653 if (cfg->dig_in_pin)
4654 snd_printd(" dig-in=0x%x\n", cfg->dig_in_pin);
4655
4656 return 0;
4657}
4658EXPORT_SYMBOL_HDA(snd_hda_parse_pin_def_config);
4659
4660int snd_hda_get_input_pin_attr(unsigned int def_conf)
4661{
4662 unsigned int loc = get_defcfg_location(def_conf);
4663 unsigned int conn = get_defcfg_connect(def_conf);
4664 if (conn == AC_JACK_PORT_NONE)
4665 return INPUT_PIN_ATTR_UNUSED;
4666
4667 if (conn == AC_JACK_PORT_FIXED || conn == AC_JACK_PORT_BOTH)
4668 return INPUT_PIN_ATTR_INT;
4669 if ((loc & 0x30) == AC_JACK_LOC_INTERNAL)
4670 return INPUT_PIN_ATTR_INT;
4671 if ((loc & 0x30) == AC_JACK_LOC_SEPARATE)
4672 return INPUT_PIN_ATTR_DOCK;
4673 if (loc == AC_JACK_LOC_REAR)
4674 return INPUT_PIN_ATTR_REAR;
4675 if (loc == AC_JACK_LOC_FRONT)
4676 return INPUT_PIN_ATTR_FRONT;
4677 return INPUT_PIN_ATTR_NORMAL;
4678}
4679EXPORT_SYMBOL_HDA(snd_hda_get_input_pin_attr);
4680
4681
4682
4683
4684
4685
4686
4687
4688
4689const char *hda_get_input_pin_label(struct hda_codec *codec, hda_nid_t pin,
4690 int check_location)
4691{
4692 unsigned int def_conf;
4693 static const char * const mic_names[] = {
4694 "Internal Mic", "Dock Mic", "Mic", "Front Mic", "Rear Mic",
4695 };
4696 int attr;
4697
4698 def_conf = snd_hda_codec_get_pincfg(codec, pin);
4699
4700 switch (get_defcfg_device(def_conf)) {
4701 case AC_JACK_MIC_IN:
4702 if (!check_location)
4703 return "Mic";
4704 attr = snd_hda_get_input_pin_attr(def_conf);
4705 if (!attr)
4706 return "None";
4707 return mic_names[attr - 1];
4708 case AC_JACK_LINE_IN:
4709 if (!check_location)
4710 return "Line";
4711 attr = snd_hda_get_input_pin_attr(def_conf);
4712 if (!attr)
4713 return "None";
4714 if (attr == INPUT_PIN_ATTR_DOCK)
4715 return "Dock Line";
4716 return "Line";
4717 case AC_JACK_AUX:
4718 return "Aux";
4719 case AC_JACK_CD:
4720 return "CD";
4721 case AC_JACK_SPDIF_IN:
4722 return "SPDIF In";
4723 case AC_JACK_DIG_OTHER_IN:
4724 return "Digital In";
4725 default:
4726 return "Misc";
4727 }
4728}
4729EXPORT_SYMBOL_HDA(hda_get_input_pin_label);
4730
4731
4732
4733
4734
4735static int check_mic_location_need(struct hda_codec *codec,
4736 const struct auto_pin_cfg *cfg,
4737 int input)
4738{
4739 unsigned int defc;
4740 int i, attr, attr2;
4741
4742 defc = snd_hda_codec_get_pincfg(codec, cfg->inputs[input].pin);
4743 attr = snd_hda_get_input_pin_attr(defc);
4744
4745 if (attr <= INPUT_PIN_ATTR_NORMAL)
4746 return 1;
4747
4748 attr = 0;
4749 for (i = 0; i < cfg->num_inputs; i++) {
4750 defc = snd_hda_codec_get_pincfg(codec, cfg->inputs[i].pin);
4751 attr2 = snd_hda_get_input_pin_attr(defc);
4752 if (attr2 >= INPUT_PIN_ATTR_NORMAL) {
4753 if (attr && attr != attr2)
4754 return 1;
4755 attr = attr2;
4756 }
4757 }
4758 return 0;
4759}
4760
4761
4762
4763
4764
4765
4766
4767
4768
4769const char *hda_get_autocfg_input_label(struct hda_codec *codec,
4770 const struct auto_pin_cfg *cfg,
4771 int input)
4772{
4773 int type = cfg->inputs[input].type;
4774 int has_multiple_pins = 0;
4775
4776 if ((input > 0 && cfg->inputs[input - 1].type == type) ||
4777 (input < cfg->num_inputs - 1 && cfg->inputs[input + 1].type == type))
4778 has_multiple_pins = 1;
4779 if (has_multiple_pins && type == AUTO_PIN_MIC)
4780 has_multiple_pins &= check_mic_location_need(codec, cfg, input);
4781 return hda_get_input_pin_label(codec, cfg->inputs[input].pin,
4782 has_multiple_pins);
4783}
4784EXPORT_SYMBOL_HDA(hda_get_autocfg_input_label);
4785
4786
4787
4788
4789
4790
4791
4792
4793int snd_hda_add_imux_item(struct hda_input_mux *imux, const char *label,
4794 int index, int *type_idx)
4795{
4796 int i, label_idx = 0;
4797 if (imux->num_items >= HDA_MAX_NUM_INPUTS) {
4798 snd_printd(KERN_ERR "hda_codec: Too many imux items!\n");
4799 return -EINVAL;
4800 }
4801 for (i = 0; i < imux->num_items; i++) {
4802 if (!strncmp(label, imux->items[i].label, strlen(label)))
4803 label_idx++;
4804 }
4805 if (type_idx)
4806 *type_idx = label_idx;
4807 if (label_idx > 0)
4808 snprintf(imux->items[imux->num_items].label,
4809 sizeof(imux->items[imux->num_items].label),
4810 "%s %d", label, label_idx);
4811 else
4812 strlcpy(imux->items[imux->num_items].label, label,
4813 sizeof(imux->items[imux->num_items].label));
4814 imux->items[imux->num_items].index = index;
4815 imux->num_items++;
4816 return 0;
4817}
4818EXPORT_SYMBOL_HDA(snd_hda_add_imux_item);
4819
4820
4821#ifdef CONFIG_PM
4822
4823
4824
4825
4826
4827
4828
4829
4830
4831
4832int snd_hda_suspend(struct hda_bus *bus)
4833{
4834 struct hda_codec *codec;
4835
4836 list_for_each_entry(codec, &bus->codec_list, list) {
4837#ifdef CONFIG_SND_HDA_POWER_SAVE
4838 if (!codec->power_on)
4839 continue;
4840#endif
4841 hda_call_codec_suspend(codec);
4842 }
4843 return 0;
4844}
4845EXPORT_SYMBOL_HDA(snd_hda_suspend);
4846
4847
4848
4849
4850
4851
4852
4853
4854
4855
4856int snd_hda_resume(struct hda_bus *bus)
4857{
4858 struct hda_codec *codec;
4859
4860 list_for_each_entry(codec, &bus->codec_list, list) {
4861 if (snd_hda_codec_needs_resume(codec))
4862 hda_call_codec_resume(codec);
4863 }
4864 return 0;
4865}
4866EXPORT_SYMBOL_HDA(snd_hda_resume);
4867#endif
4868
4869
4870
4871
4872
4873
4874
4875
4876
4877
4878
4879
4880
4881
4882void *snd_array_new(struct snd_array *array)
4883{
4884 if (array->used >= array->alloced) {
4885 int num = array->alloced + array->alloc_align;
4886 void *nlist;
4887 if (snd_BUG_ON(num >= 4096))
4888 return NULL;
4889 nlist = kcalloc(num + 1, array->elem_size, GFP_KERNEL);
4890 if (!nlist)
4891 return NULL;
4892 if (array->list) {
4893 memcpy(nlist, array->list,
4894 array->elem_size * array->alloced);
4895 kfree(array->list);
4896 }
4897 array->list = nlist;
4898 array->alloced = num;
4899 }
4900 return snd_array_elem(array, array->used++);
4901}
4902EXPORT_SYMBOL_HDA(snd_array_new);
4903
4904
4905
4906
4907
4908void snd_array_free(struct snd_array *array)
4909{
4910 kfree(array->list);
4911 array->used = 0;
4912 array->alloced = 0;
4913 array->list = NULL;
4914}
4915EXPORT_SYMBOL_HDA(snd_array_free);
4916
4917
4918
4919
4920
4921
4922
4923
4924
4925void snd_print_pcm_rates(int pcm, char *buf, int buflen)
4926{
4927 static unsigned int rates[] = {
4928 8000, 11025, 16000, 22050, 32000, 44100, 48000, 88200,
4929 96000, 176400, 192000, 384000
4930 };
4931 int i, j;
4932
4933 for (i = 0, j = 0; i < ARRAY_SIZE(rates); i++)
4934 if (pcm & (1 << i))
4935 j += snprintf(buf + j, buflen - j, " %d", rates[i]);
4936
4937 buf[j] = '\0';
4938}
4939EXPORT_SYMBOL_HDA(snd_print_pcm_rates);
4940
4941
4942
4943
4944
4945
4946
4947
4948
4949void snd_print_pcm_bits(int pcm, char *buf, int buflen)
4950{
4951 static unsigned int bits[] = { 8, 16, 20, 24, 32 };
4952 int i, j;
4953
4954 for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++)
4955 if (pcm & (AC_SUPPCM_BITS_8 << i))
4956 j += snprintf(buf + j, buflen - j, " %d", bits[i]);
4957
4958 buf[j] = '\0';
4959}
4960EXPORT_SYMBOL_HDA(snd_print_pcm_bits);
4961
4962MODULE_DESCRIPTION("HDA codec core");
4963MODULE_LICENSE("GPL");
4964