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