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