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