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