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