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