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