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