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