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