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