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 "On", "Off", "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 snd_hda_jack_set_dirty_all(codec); 3658 if (codec->patch_ops.resume) 3659 codec->patch_ops.resume(codec); 3660 else { 3661 if (codec->patch_ops.init) 3662 codec->patch_ops.init(codec); 3663 snd_hda_codec_resume_amp(codec); 3664 snd_hda_codec_resume_cache(codec); 3665 } 3666 3667 if (codec->jackpoll_interval) 3668 hda_jackpoll_work(&codec->jackpoll_work.work); 3669 else 3670 snd_hda_jack_report_sync(codec); 3671 3672 codec->in_pm = 0; 3673 snd_hda_power_down(codec); /* flag down before returning */ 3674 } 3675 #endif /* CONFIG_PM */ 3676 3677 3678 /** 3679 * snd_hda_build_controls - build mixer controls 3680 * @bus: the BUS 3681 * 3682 * Creates mixer controls for each codec included in the bus. 3683 * 3684 * Returns 0 if successful, otherwise a negative error code. 3685 */ 3686 int snd_hda_build_controls(struct hda_bus *bus) 3687 { 3688 struct hda_codec *codec; 3689 3690 list_for_each_entry(codec, &bus->codec_list, list) { 3691 int err = snd_hda_codec_build_controls(codec); 3692 if (err < 0) { 3693 printk(KERN_ERR "hda_codec: cannot build controls " 3694 "for #%d (error %d)\n", codec->addr, err); 3695 err = snd_hda_codec_reset(codec); 3696 if (err < 0) { 3697 printk(KERN_ERR 3698 "hda_codec: cannot revert codec\n"); 3699 return err; 3700 } 3701 } 3702 } 3703 return 0; 3704 } 3705 EXPORT_SYMBOL_HDA(snd_hda_build_controls); 3706 3707 /* 3708 * add standard channel maps if not specified 3709 */ 3710 static int add_std_chmaps(struct hda_codec *codec) 3711 { 3712 int i, str, err; 3713 3714 for (i = 0; i < codec->num_pcms; i++) { 3715 for (str = 0; str < 2; str++) { 3716 struct snd_pcm *pcm = codec->pcm_info[i].pcm; 3717 struct hda_pcm_stream *hinfo = 3718 &codec->pcm_info[i].stream[str]; 3719 struct snd_pcm_chmap *chmap; 3720 const struct snd_pcm_chmap_elem *elem; 3721 3722 if (codec->pcm_info[i].own_chmap) 3723 continue; 3724 if (!pcm || !hinfo->substreams) 3725 continue; 3726 elem = hinfo->chmap ? hinfo->chmap : snd_pcm_std_chmaps; 3727 err = snd_pcm_add_chmap_ctls(pcm, str, elem, 3728 hinfo->channels_max, 3729 0, &chmap); 3730 if (err < 0) 3731 return err; 3732 chmap->channel_mask = SND_PCM_CHMAP_MASK_2468; 3733 } 3734 } 3735 return 0; 3736 } 3737 3738 /* default channel maps for 2.1 speakers; 3739 * since HD-audio supports only stereo, odd number channels are omitted 3740 */ 3741 const struct snd_pcm_chmap_elem snd_pcm_2_1_chmaps[] = { 3742 { .channels = 2, 3743 .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR } }, 3744 { .channels = 4, 3745 .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, 3746 SNDRV_CHMAP_LFE, SNDRV_CHMAP_LFE } }, 3747 { } 3748 }; 3749 EXPORT_SYMBOL_GPL(snd_pcm_2_1_chmaps); 3750 3751 int snd_hda_codec_build_controls(struct hda_codec *codec) 3752 { 3753 int err = 0; 3754 hda_exec_init_verbs(codec); 3755 /* continue to initialize... */ 3756 if (codec->patch_ops.init) 3757 err = codec->patch_ops.init(codec); 3758 if (!err && codec->patch_ops.build_controls) 3759 err = codec->patch_ops.build_controls(codec); 3760 if (err < 0) 3761 return err; 3762 3763 /* we create chmaps here instead of build_pcms */ 3764 err = add_std_chmaps(codec); 3765 if (err < 0) 3766 return err; 3767 3768 if (codec->jackpoll_interval) 3769 hda_jackpoll_work(&codec->jackpoll_work.work); 3770 else 3771 snd_hda_jack_report_sync(codec); /* call at the last init point */ 3772 return 0; 3773 } 3774 3775 /* 3776 * stream formats 3777 */ 3778 struct hda_rate_tbl { 3779 unsigned int hz; 3780 unsigned int alsa_bits; 3781 unsigned int hda_fmt; 3782 }; 3783 3784 /* rate = base * mult / div */ 3785 #define HDA_RATE(base, mult, div) \ 3786 (AC_FMT_BASE_##base##K | (((mult) - 1) << AC_FMT_MULT_SHIFT) | \ 3787 (((div) - 1) << AC_FMT_DIV_SHIFT)) 3788 3789 static struct hda_rate_tbl rate_bits[] = { 3790 /* rate in Hz, ALSA rate bitmask, HDA format value */ 3791 3792 /* autodetected value used in snd_hda_query_supported_pcm */ 3793 { 8000, SNDRV_PCM_RATE_8000, HDA_RATE(48, 1, 6) }, 3794 { 11025, SNDRV_PCM_RATE_11025, HDA_RATE(44, 1, 4) }, 3795 { 16000, SNDRV_PCM_RATE_16000, HDA_RATE(48, 1, 3) }, 3796 { 22050, SNDRV_PCM_RATE_22050, HDA_RATE(44, 1, 2) }, 3797 { 32000, SNDRV_PCM_RATE_32000, HDA_RATE(48, 2, 3) }, 3798 { 44100, SNDRV_PCM_RATE_44100, HDA_RATE(44, 1, 1) }, 3799 { 48000, SNDRV_PCM_RATE_48000, HDA_RATE(48, 1, 1) }, 3800 { 88200, SNDRV_PCM_RATE_88200, HDA_RATE(44, 2, 1) }, 3801 { 96000, SNDRV_PCM_RATE_96000, HDA_RATE(48, 2, 1) }, 3802 { 176400, SNDRV_PCM_RATE_176400, HDA_RATE(44, 4, 1) }, 3803 { 192000, SNDRV_PCM_RATE_192000, HDA_RATE(48, 4, 1) }, 3804 #define AC_PAR_PCM_RATE_BITS 11 3805 /* up to bits 10, 384kHZ isn't supported properly */ 3806 3807 /* not autodetected value */ 3808 { 9600, SNDRV_PCM_RATE_KNOT, HDA_RATE(48, 1, 5) }, 3809 3810 { 0 } /* terminator */ 3811 }; 3812 3813 /** 3814 * snd_hda_calc_stream_format - calculate format bitset 3815 * @rate: the sample rate 3816 * @channels: the number of channels 3817 * @format: the PCM format (SNDRV_PCM_FORMAT_XXX) 3818 * @maxbps: the max. bps 3819 * 3820 * Calculate the format bitset from the given rate, channels and th PCM format. 3821 * 3822 * Return zero if invalid. 3823 */ 3824 unsigned int snd_hda_calc_stream_format(unsigned int rate, 3825 unsigned int channels, 3826 unsigned int format, 3827 unsigned int maxbps, 3828 unsigned short spdif_ctls) 3829 { 3830 int i; 3831 unsigned int val = 0; 3832 3833 for (i = 0; rate_bits[i].hz; i++) 3834 if (rate_bits[i].hz == rate) { 3835 val = rate_bits[i].hda_fmt; 3836 break; 3837 } 3838 if (!rate_bits[i].hz) { 3839 snd_printdd("invalid rate %d\n", rate); 3840 return 0; 3841 } 3842 3843 if (channels == 0 || channels > 8) { 3844 snd_printdd("invalid channels %d\n", channels); 3845 return 0; 3846 } 3847 val |= channels - 1; 3848 3849 switch (snd_pcm_format_width(format)) { 3850 case 8: 3851 val |= AC_FMT_BITS_8; 3852 break; 3853 case 16: 3854 val |= AC_FMT_BITS_16; 3855 break; 3856 case 20: 3857 case 24: 3858 case 32: 3859 if (maxbps >= 32 || format == SNDRV_PCM_FORMAT_FLOAT_LE) 3860 val |= AC_FMT_BITS_32; 3861 else if (maxbps >= 24) 3862 val |= AC_FMT_BITS_24; 3863 else 3864 val |= AC_FMT_BITS_20; 3865 break; 3866 default: 3867 snd_printdd("invalid format width %d\n", 3868 snd_pcm_format_width(format)); 3869 return 0; 3870 } 3871 3872 if (spdif_ctls & AC_DIG1_NONAUDIO) 3873 val |= AC_FMT_TYPE_NON_PCM; 3874 3875 return val; 3876 } 3877 EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format); 3878 3879 static unsigned int get_pcm_param(struct hda_codec *codec, hda_nid_t nid, 3880 int dir) 3881 { 3882 unsigned int val = 0; 3883 if (nid != codec->afg && 3884 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD)) 3885 val = snd_hda_param_read(codec, nid, AC_PAR_PCM); 3886 if (!val || val == -1) 3887 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM); 3888 if (!val || val == -1) 3889 return 0; 3890 return val; 3891 } 3892 3893 static unsigned int query_pcm_param(struct hda_codec *codec, hda_nid_t nid) 3894 { 3895 return query_caps_hash(codec, nid, 0, HDA_HASH_PARPCM_KEY(nid), 3896 get_pcm_param); 3897 } 3898 3899 static unsigned int get_stream_param(struct hda_codec *codec, hda_nid_t nid, 3900 int dir) 3901 { 3902 unsigned int streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM); 3903 if (!streams || streams == -1) 3904 streams = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM); 3905 if (!streams || streams == -1) 3906 return 0; 3907 return streams; 3908 } 3909 3910 static unsigned int query_stream_param(struct hda_codec *codec, hda_nid_t nid) 3911 { 3912 return query_caps_hash(codec, nid, 0, HDA_HASH_PARSTR_KEY(nid), 3913 get_stream_param); 3914 } 3915 3916 /** 3917 * snd_hda_query_supported_pcm - query the supported PCM rates and formats 3918 * @codec: the HDA codec 3919 * @nid: NID to query 3920 * @ratesp: the pointer to store the detected rate bitflags 3921 * @formatsp: the pointer to store the detected formats 3922 * @bpsp: the pointer to store the detected format widths 3923 * 3924 * Queries the supported PCM rates and formats. The NULL @ratesp, @formatsp 3925 * or @bsps argument is ignored. 3926 * 3927 * Returns 0 if successful, otherwise a negative error code. 3928 */ 3929 int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid, 3930 u32 *ratesp, u64 *formatsp, unsigned int *bpsp) 3931 { 3932 unsigned int i, val, wcaps; 3933 3934 wcaps = get_wcaps(codec, nid); 3935 val = query_pcm_param(codec, nid); 3936 3937 if (ratesp) { 3938 u32 rates = 0; 3939 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) { 3940 if (val & (1 << i)) 3941 rates |= rate_bits[i].alsa_bits; 3942 } 3943 if (rates == 0) { 3944 snd_printk(KERN_ERR "hda_codec: rates == 0 " 3945 "(nid=0x%x, val=0x%x, ovrd=%i)\n", 3946 nid, val, 3947 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0); 3948 return -EIO; 3949 } 3950 *ratesp = rates; 3951 } 3952 3953 if (formatsp || bpsp) { 3954 u64 formats = 0; 3955 unsigned int streams, bps; 3956 3957 streams = query_stream_param(codec, nid); 3958 if (!streams) 3959 return -EIO; 3960 3961 bps = 0; 3962 if (streams & AC_SUPFMT_PCM) { 3963 if (val & AC_SUPPCM_BITS_8) { 3964 formats |= SNDRV_PCM_FMTBIT_U8; 3965 bps = 8; 3966 } 3967 if (val & AC_SUPPCM_BITS_16) { 3968 formats |= SNDRV_PCM_FMTBIT_S16_LE; 3969 bps = 16; 3970 } 3971 if (wcaps & AC_WCAP_DIGITAL) { 3972 if (val & AC_SUPPCM_BITS_32) 3973 formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE; 3974 if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24)) 3975 formats |= SNDRV_PCM_FMTBIT_S32_LE; 3976 if (val & AC_SUPPCM_BITS_24) 3977 bps = 24; 3978 else if (val & AC_SUPPCM_BITS_20) 3979 bps = 20; 3980 } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24| 3981 AC_SUPPCM_BITS_32)) { 3982 formats |= SNDRV_PCM_FMTBIT_S32_LE; 3983 if (val & AC_SUPPCM_BITS_32) 3984 bps = 32; 3985 else if (val & AC_SUPPCM_BITS_24) 3986 bps = 24; 3987 else if (val & AC_SUPPCM_BITS_20) 3988 bps = 20; 3989 } 3990 } 3991 #if 0 /* FIXME: CS4206 doesn't work, which is the only codec supporting float */ 3992 if (streams & AC_SUPFMT_FLOAT32) { 3993 formats |= SNDRV_PCM_FMTBIT_FLOAT_LE; 3994 if (!bps) 3995 bps = 32; 3996 } 3997 #endif 3998 if (streams == AC_SUPFMT_AC3) { 3999 /* should be exclusive */ 4000 /* temporary hack: we have still no proper support 4001 * for the direct AC3 stream... 4002 */ 4003 formats |= SNDRV_PCM_FMTBIT_U8; 4004 bps = 8; 4005 } 4006 if (formats == 0) { 4007 snd_printk(KERN_ERR "hda_codec: formats == 0 " 4008 "(nid=0x%x, val=0x%x, ovrd=%i, " 4009 "streams=0x%x)\n", 4010 nid, val, 4011 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0, 4012 streams); 4013 return -EIO; 4014 } 4015 if (formatsp) 4016 *formatsp = formats; 4017 if (bpsp) 4018 *bpsp = bps; 4019 } 4020 4021 return 0; 4022 } 4023 EXPORT_SYMBOL_HDA(snd_hda_query_supported_pcm); 4024 4025 /** 4026 * snd_hda_is_supported_format - Check the validity of the format 4027 * @codec: HD-audio codec 4028 * @nid: NID to check 4029 * @format: the HD-audio format value to check 4030 * 4031 * Check whether the given node supports the format value. 4032 * 4033 * Returns 1 if supported, 0 if not. 4034 */ 4035 int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid, 4036 unsigned int format) 4037 { 4038 int i; 4039 unsigned int val = 0, rate, stream; 4040 4041 val = query_pcm_param(codec, nid); 4042 if (!val) 4043 return 0; 4044 4045 rate = format & 0xff00; 4046 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) 4047 if (rate_bits[i].hda_fmt == rate) { 4048 if (val & (1 << i)) 4049 break; 4050 return 0; 4051 } 4052 if (i >= AC_PAR_PCM_RATE_BITS) 4053 return 0; 4054 4055 stream = query_stream_param(codec, nid); 4056 if (!stream) 4057 return 0; 4058 4059 if (stream & AC_SUPFMT_PCM) { 4060 switch (format & 0xf0) { 4061 case 0x00: 4062 if (!(val & AC_SUPPCM_BITS_8)) 4063 return 0; 4064 break; 4065 case 0x10: 4066 if (!(val & AC_SUPPCM_BITS_16)) 4067 return 0; 4068 break; 4069 case 0x20: 4070 if (!(val & AC_SUPPCM_BITS_20)) 4071 return 0; 4072 break; 4073 case 0x30: 4074 if (!(val & AC_SUPPCM_BITS_24)) 4075 return 0; 4076 break; 4077 case 0x40: 4078 if (!(val & AC_SUPPCM_BITS_32)) 4079 return 0; 4080 break; 4081 default: 4082 return 0; 4083 } 4084 } else { 4085 /* FIXME: check for float32 and AC3? */ 4086 } 4087 4088 return 1; 4089 } 4090 EXPORT_SYMBOL_HDA(snd_hda_is_supported_format); 4091 4092 /* 4093 * PCM stuff 4094 */ 4095 static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo, 4096 struct hda_codec *codec, 4097 struct snd_pcm_substream *substream) 4098 { 4099 return 0; 4100 } 4101 4102 static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo, 4103 struct hda_codec *codec, 4104 unsigned int stream_tag, 4105 unsigned int format, 4106 struct snd_pcm_substream *substream) 4107 { 4108 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format); 4109 return 0; 4110 } 4111 4112 static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo, 4113 struct hda_codec *codec, 4114 struct snd_pcm_substream *substream) 4115 { 4116 snd_hda_codec_cleanup_stream(codec, hinfo->nid); 4117 return 0; 4118 } 4119 4120 static int set_pcm_default_values(struct hda_codec *codec, 4121 struct hda_pcm_stream *info) 4122 { 4123 int err; 4124 4125 /* query support PCM information from the given NID */ 4126 if (info->nid && (!info->rates || !info->formats)) { 4127 err = snd_hda_query_supported_pcm(codec, info->nid, 4128 info->rates ? NULL : &info->rates, 4129 info->formats ? NULL : &info->formats, 4130 info->maxbps ? NULL : &info->maxbps); 4131 if (err < 0) 4132 return err; 4133 } 4134 if (info->ops.open == NULL) 4135 info->ops.open = hda_pcm_default_open_close; 4136 if (info->ops.close == NULL) 4137 info->ops.close = hda_pcm_default_open_close; 4138 if (info->ops.prepare == NULL) { 4139 if (snd_BUG_ON(!info->nid)) 4140 return -EINVAL; 4141 info->ops.prepare = hda_pcm_default_prepare; 4142 } 4143 if (info->ops.cleanup == NULL) { 4144 if (snd_BUG_ON(!info->nid)) 4145 return -EINVAL; 4146 info->ops.cleanup = hda_pcm_default_cleanup; 4147 } 4148 return 0; 4149 } 4150 4151 /* 4152 * codec prepare/cleanup entries 4153 */ 4154 int snd_hda_codec_prepare(struct hda_codec *codec, 4155 struct hda_pcm_stream *hinfo, 4156 unsigned int stream, 4157 unsigned int format, 4158 struct snd_pcm_substream *substream) 4159 { 4160 int ret; 4161 mutex_lock(&codec->bus->prepare_mutex); 4162 ret = hinfo->ops.prepare(hinfo, codec, stream, format, substream); 4163 if (ret >= 0) 4164 purify_inactive_streams(codec); 4165 mutex_unlock(&codec->bus->prepare_mutex); 4166 return ret; 4167 } 4168 EXPORT_SYMBOL_HDA(snd_hda_codec_prepare); 4169 4170 void snd_hda_codec_cleanup(struct hda_codec *codec, 4171 struct hda_pcm_stream *hinfo, 4172 struct snd_pcm_substream *substream) 4173 { 4174 mutex_lock(&codec->bus->prepare_mutex); 4175 hinfo->ops.cleanup(hinfo, codec, substream); 4176 mutex_unlock(&codec->bus->prepare_mutex); 4177 } 4178 EXPORT_SYMBOL_HDA(snd_hda_codec_cleanup); 4179 4180 /* global */ 4181 const char *snd_hda_pcm_type_name[HDA_PCM_NTYPES] = { 4182 "Audio", "SPDIF", "HDMI", "Modem" 4183 }; 4184 4185 /* 4186 * get the empty PCM device number to assign 4187 * 4188 * note the max device number is limited by HDA_MAX_PCMS, currently 10 4189 */ 4190 static int get_empty_pcm_device(struct hda_bus *bus, int type) 4191 { 4192 /* audio device indices; not linear to keep compatibility */ 4193 static int audio_idx[HDA_PCM_NTYPES][5] = { 4194 [HDA_PCM_TYPE_AUDIO] = { 0, 2, 4, 5, -1 }, 4195 [HDA_PCM_TYPE_SPDIF] = { 1, -1 }, 4196 [HDA_PCM_TYPE_HDMI] = { 3, 7, 8, 9, -1 }, 4197 [HDA_PCM_TYPE_MODEM] = { 6, -1 }, 4198 }; 4199 int i; 4200 4201 if (type >= HDA_PCM_NTYPES) { 4202 snd_printk(KERN_WARNING "Invalid PCM type %d\n", type); 4203 return -EINVAL; 4204 } 4205 4206 for (i = 0; audio_idx[type][i] >= 0 ; i++) 4207 if (!test_and_set_bit(audio_idx[type][i], bus->pcm_dev_bits)) 4208 return audio_idx[type][i]; 4209 4210 /* non-fixed slots starting from 10 */ 4211 for (i = 10; i < 32; i++) { 4212 if (!test_and_set_bit(i, bus->pcm_dev_bits)) 4213 return i; 4214 } 4215 4216 snd_printk(KERN_WARNING "Too many %s devices\n", 4217 snd_hda_pcm_type_name[type]); 4218 return -EAGAIN; 4219 } 4220 4221 /* 4222 * attach a new PCM stream 4223 */ 4224 static int snd_hda_attach_pcm(struct hda_codec *codec, struct hda_pcm *pcm) 4225 { 4226 struct hda_bus *bus = codec->bus; 4227 struct hda_pcm_stream *info; 4228 int stream, err; 4229 4230 if (snd_BUG_ON(!pcm->name)) 4231 return -EINVAL; 4232 for (stream = 0; stream < 2; stream++) { 4233 info = &pcm->stream[stream]; 4234 if (info->substreams) { 4235 err = set_pcm_default_values(codec, info); 4236 if (err < 0) 4237 return err; 4238 } 4239 } 4240 return bus->ops.attach_pcm(bus, codec, pcm); 4241 } 4242 4243 /* assign all PCMs of the given codec */ 4244 int snd_hda_codec_build_pcms(struct hda_codec *codec) 4245 { 4246 unsigned int pcm; 4247 int err; 4248 4249 if (!codec->num_pcms) { 4250 if (!codec->patch_ops.build_pcms) 4251 return 0; 4252 err = codec->patch_ops.build_pcms(codec); 4253 if (err < 0) { 4254 printk(KERN_ERR "hda_codec: cannot build PCMs" 4255 "for #%d (error %d)\n", codec->addr, err); 4256 err = snd_hda_codec_reset(codec); 4257 if (err < 0) { 4258 printk(KERN_ERR 4259 "hda_codec: cannot revert codec\n"); 4260 return err; 4261 } 4262 } 4263 } 4264 for (pcm = 0; pcm < codec->num_pcms; pcm++) { 4265 struct hda_pcm *cpcm = &codec->pcm_info[pcm]; 4266 int dev; 4267 4268 if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams) 4269 continue; /* no substreams assigned */ 4270 4271 if (!cpcm->pcm) { 4272 dev = get_empty_pcm_device(codec->bus, cpcm->pcm_type); 4273 if (dev < 0) 4274 continue; /* no fatal error */ 4275 cpcm->device = dev; 4276 err = snd_hda_attach_pcm(codec, cpcm); 4277 if (err < 0) { 4278 printk(KERN_ERR "hda_codec: cannot attach " 4279 "PCM stream %d for codec #%d\n", 4280 dev, codec->addr); 4281 continue; /* no fatal error */ 4282 } 4283 } 4284 } 4285 return 0; 4286 } 4287 4288 /** 4289 * snd_hda_build_pcms - build PCM information 4290 * @bus: the BUS 4291 * 4292 * Create PCM information for each codec included in the bus. 4293 * 4294 * The build_pcms codec patch is requested to set up codec->num_pcms and 4295 * codec->pcm_info properly. The array is referred by the top-level driver 4296 * to create its PCM instances. 4297 * The allocated codec->pcm_info should be released in codec->patch_ops.free 4298 * callback. 4299 * 4300 * At least, substreams, channels_min and channels_max must be filled for 4301 * each stream. substreams = 0 indicates that the stream doesn't exist. 4302 * When rates and/or formats are zero, the supported values are queried 4303 * from the given nid. The nid is used also by the default ops.prepare 4304 * and ops.cleanup callbacks. 4305 * 4306 * The driver needs to call ops.open in its open callback. Similarly, 4307 * ops.close is supposed to be called in the close callback. 4308 * ops.prepare should be called in the prepare or hw_params callback 4309 * with the proper parameters for set up. 4310 * ops.cleanup should be called in hw_free for clean up of streams. 4311 * 4312 * This function returns 0 if successful, or a negative error code. 4313 */ 4314 int snd_hda_build_pcms(struct hda_bus *bus) 4315 { 4316 struct hda_codec *codec; 4317 4318 list_for_each_entry(codec, &bus->codec_list, list) { 4319 int err = snd_hda_codec_build_pcms(codec); 4320 if (err < 0) 4321 return err; 4322 } 4323 return 0; 4324 } 4325 EXPORT_SYMBOL_HDA(snd_hda_build_pcms); 4326 4327 /** 4328 * snd_hda_check_board_config - compare the current codec with the config table 4329 * @codec: the HDA codec 4330 * @num_configs: number of config enums 4331 * @models: array of model name strings 4332 * @tbl: configuration table, terminated by null entries 4333 * 4334 * Compares the modelname or PCI subsystem id of the current codec with the 4335 * given configuration table. If a matching entry is found, returns its 4336 * config value (supposed to be 0 or positive). 4337 * 4338 * If no entries are matching, the function returns a negative value. 4339 */ 4340 int snd_hda_check_board_config(struct hda_codec *codec, 4341 int num_configs, const char * const *models, 4342 const struct snd_pci_quirk *tbl) 4343 { 4344 if (codec->modelname && models) { 4345 int i; 4346 for (i = 0; i < num_configs; i++) { 4347 if (models[i] && 4348 !strcmp(codec->modelname, models[i])) { 4349 snd_printd(KERN_INFO "hda_codec: model '%s' is " 4350 "selected\n", models[i]); 4351 return i; 4352 } 4353 } 4354 } 4355 4356 if (!codec->bus->pci || !tbl) 4357 return -1; 4358 4359 tbl = snd_pci_quirk_lookup(codec->bus->pci, tbl); 4360 if (!tbl) 4361 return -1; 4362 if (tbl->value >= 0 && tbl->value < num_configs) { 4363 #ifdef CONFIG_SND_DEBUG_VERBOSE 4364 char tmp[10]; 4365 const char *model = NULL; 4366 if (models) 4367 model = models[tbl->value]; 4368 if (!model) { 4369 sprintf(tmp, "#%d", tbl->value); 4370 model = tmp; 4371 } 4372 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected " 4373 "for config %x:%x (%s)\n", 4374 model, tbl->subvendor, tbl->subdevice, 4375 (tbl->name ? tbl->name : "Unknown device")); 4376 #endif 4377 return tbl->value; 4378 } 4379 return -1; 4380 } 4381 EXPORT_SYMBOL_HDA(snd_hda_check_board_config); 4382 4383 /** 4384 * snd_hda_check_board_codec_sid_config - compare the current codec 4385 subsystem ID with the 4386 config table 4387 4388 This is important for Gateway notebooks with SB450 HDA Audio 4389 where the vendor ID of the PCI device is: 4390 ATI Technologies Inc SB450 HDA Audio [1002:437b] 4391 and the vendor/subvendor are found only at the codec. 4392 4393 * @codec: the HDA codec 4394 * @num_configs: number of config enums 4395 * @models: array of model name strings 4396 * @tbl: configuration table, terminated by null entries 4397 * 4398 * Compares the modelname or PCI subsystem id of the current codec with the 4399 * given configuration table. If a matching entry is found, returns its 4400 * config value (supposed to be 0 or positive). 4401 * 4402 * If no entries are matching, the function returns a negative value. 4403 */ 4404 int snd_hda_check_board_codec_sid_config(struct hda_codec *codec, 4405 int num_configs, const char * const *models, 4406 const struct snd_pci_quirk *tbl) 4407 { 4408 const struct snd_pci_quirk *q; 4409 4410 /* Search for codec ID */ 4411 for (q = tbl; q->subvendor; q++) { 4412 unsigned int mask = 0xffff0000 | q->subdevice_mask; 4413 unsigned int id = (q->subdevice | (q->subvendor << 16)) & mask; 4414 if ((codec->subsystem_id & mask) == id) 4415 break; 4416 } 4417 4418 if (!q->subvendor) 4419 return -1; 4420 4421 tbl = q; 4422 4423 if (tbl->value >= 0 && tbl->value < num_configs) { 4424 #ifdef CONFIG_SND_DEBUG_VERBOSE 4425 char tmp[10]; 4426 const char *model = NULL; 4427 if (models) 4428 model = models[tbl->value]; 4429 if (!model) { 4430 sprintf(tmp, "#%d", tbl->value); 4431 model = tmp; 4432 } 4433 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected " 4434 "for config %x:%x (%s)\n", 4435 model, tbl->subvendor, tbl->subdevice, 4436 (tbl->name ? tbl->name : "Unknown device")); 4437 #endif 4438 return tbl->value; 4439 } 4440 return -1; 4441 } 4442 EXPORT_SYMBOL_HDA(snd_hda_check_board_codec_sid_config); 4443 4444 /** 4445 * snd_hda_add_new_ctls - create controls from the array 4446 * @codec: the HDA codec 4447 * @knew: the array of struct snd_kcontrol_new 4448 * 4449 * This helper function creates and add new controls in the given array. 4450 * The array must be terminated with an empty entry as terminator. 4451 * 4452 * Returns 0 if successful, or a negative error code. 4453 */ 4454 int snd_hda_add_new_ctls(struct hda_codec *codec, 4455 const struct snd_kcontrol_new *knew) 4456 { 4457 int err; 4458 4459 for (; knew->name; knew++) { 4460 struct snd_kcontrol *kctl; 4461 int addr = 0, idx = 0; 4462 if (knew->iface == -1) /* skip this codec private value */ 4463 continue; 4464 for (;;) { 4465 kctl = snd_ctl_new1(knew, codec); 4466 if (!kctl) 4467 return -ENOMEM; 4468 if (addr > 0) 4469 kctl->id.device = addr; 4470 if (idx > 0) 4471 kctl->id.index = idx; 4472 err = snd_hda_ctl_add(codec, 0, kctl); 4473 if (!err) 4474 break; 4475 /* try first with another device index corresponding to 4476 * the codec addr; if it still fails (or it's the 4477 * primary codec), then try another control index 4478 */ 4479 if (!addr && codec->addr) 4480 addr = codec->addr; 4481 else if (!idx && !knew->index) { 4482 idx = find_empty_mixer_ctl_idx(codec, 4483 knew->name, 0); 4484 if (idx <= 0) 4485 return err; 4486 } else 4487 return err; 4488 } 4489 } 4490 return 0; 4491 } 4492 EXPORT_SYMBOL_HDA(snd_hda_add_new_ctls); 4493 4494 #ifdef CONFIG_PM 4495 static void hda_power_work(struct work_struct *work) 4496 { 4497 struct hda_codec *codec = 4498 container_of(work, struct hda_codec, power_work.work); 4499 struct hda_bus *bus = codec->bus; 4500 unsigned int state; 4501 4502 spin_lock(&codec->power_lock); 4503 if (codec->power_transition > 0) { /* during power-up sequence? */ 4504 spin_unlock(&codec->power_lock); 4505 return; 4506 } 4507 if (!codec->power_on || codec->power_count) { 4508 codec->power_transition = 0; 4509 spin_unlock(&codec->power_lock); 4510 return; 4511 } 4512 spin_unlock(&codec->power_lock); 4513 4514 state = hda_call_codec_suspend(codec, true); 4515 codec->pm_down_notified = 0; 4516 if (!bus->power_keep_link_on && (state & AC_PWRST_CLK_STOP_OK)) { 4517 codec->pm_down_notified = 1; 4518 hda_call_pm_notify(bus, false); 4519 } 4520 } 4521 4522 static void hda_keep_power_on(struct hda_codec *codec) 4523 { 4524 spin_lock(&codec->power_lock); 4525 codec->power_count++; 4526 codec->power_on = 1; 4527 codec->power_jiffies = jiffies; 4528 spin_unlock(&codec->power_lock); 4529 } 4530 4531 /* update the power on/off account with the current jiffies */ 4532 void snd_hda_update_power_acct(struct hda_codec *codec) 4533 { 4534 unsigned long delta = jiffies - codec->power_jiffies; 4535 if (codec->power_on) 4536 codec->power_on_acct += delta; 4537 else 4538 codec->power_off_acct += delta; 4539 codec->power_jiffies += delta; 4540 } 4541 4542 /* Transition to powered up, if wait_power_down then wait for a pending 4543 * transition to D3 to complete. A pending D3 transition is indicated 4544 * with power_transition == -1. */ 4545 /* call this with codec->power_lock held! */ 4546 static void __snd_hda_power_up(struct hda_codec *codec, bool wait_power_down) 4547 { 4548 struct hda_bus *bus = codec->bus; 4549 4550 /* Return if power_on or transitioning to power_on, unless currently 4551 * powering down. */ 4552 if ((codec->power_on || codec->power_transition > 0) && 4553 !(wait_power_down && codec->power_transition < 0)) 4554 return; 4555 spin_unlock(&codec->power_lock); 4556 4557 cancel_delayed_work_sync(&codec->power_work); 4558 4559 spin_lock(&codec->power_lock); 4560 /* If the power down delayed work was cancelled above before starting, 4561 * then there is no need to go through power up here. 4562 */ 4563 if (codec->power_on) { 4564 if (codec->power_transition < 0) 4565 codec->power_transition = 0; 4566 return; 4567 } 4568 4569 trace_hda_power_up(codec); 4570 snd_hda_update_power_acct(codec); 4571 codec->power_on = 1; 4572 codec->power_jiffies = jiffies; 4573 codec->power_transition = 1; /* avoid reentrance */ 4574 spin_unlock(&codec->power_lock); 4575 4576 if (codec->pm_down_notified) { 4577 codec->pm_down_notified = 0; 4578 hda_call_pm_notify(bus, true); 4579 } 4580 4581 hda_call_codec_resume(codec); 4582 4583 spin_lock(&codec->power_lock); 4584 codec->power_transition = 0; 4585 } 4586 4587 #define power_save(codec) \ 4588 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0) 4589 4590 /* Transition to powered down */ 4591 static void __snd_hda_power_down(struct hda_codec *codec) 4592 { 4593 if (!codec->power_on || codec->power_count || codec->power_transition) 4594 return; 4595 4596 if (power_save(codec)) { 4597 codec->power_transition = -1; /* avoid reentrance */ 4598 queue_delayed_work(codec->bus->workq, &codec->power_work, 4599 msecs_to_jiffies(power_save(codec) * 1000)); 4600 } 4601 } 4602 4603 /** 4604 * snd_hda_power_save - Power-up/down/sync the codec 4605 * @codec: HD-audio codec 4606 * @delta: the counter delta to change 4607 * 4608 * Change the power-up counter via @delta, and power up or down the hardware 4609 * appropriately. For the power-down, queue to the delayed action. 4610 * Passing zero to @delta means to synchronize the power state. 4611 */ 4612 void snd_hda_power_save(struct hda_codec *codec, int delta, bool d3wait) 4613 { 4614 spin_lock(&codec->power_lock); 4615 codec->power_count += delta; 4616 trace_hda_power_count(codec); 4617 if (delta > 0) 4618 __snd_hda_power_up(codec, d3wait); 4619 else 4620 __snd_hda_power_down(codec); 4621 spin_unlock(&codec->power_lock); 4622 } 4623 EXPORT_SYMBOL_HDA(snd_hda_power_save); 4624 4625 /** 4626 * snd_hda_check_amp_list_power - Check the amp list and update the power 4627 * @codec: HD-audio codec 4628 * @check: the object containing an AMP list and the status 4629 * @nid: NID to check / update 4630 * 4631 * Check whether the given NID is in the amp list. If it's in the list, 4632 * check the current AMP status, and update the the power-status according 4633 * to the mute status. 4634 * 4635 * This function is supposed to be set or called from the check_power_status 4636 * patch ops. 4637 */ 4638 int snd_hda_check_amp_list_power(struct hda_codec *codec, 4639 struct hda_loopback_check *check, 4640 hda_nid_t nid) 4641 { 4642 const struct hda_amp_list *p; 4643 int ch, v; 4644 4645 if (!check->amplist) 4646 return 0; 4647 for (p = check->amplist; p->nid; p++) { 4648 if (p->nid == nid) 4649 break; 4650 } 4651 if (!p->nid) 4652 return 0; /* nothing changed */ 4653 4654 for (p = check->amplist; p->nid; p++) { 4655 for (ch = 0; ch < 2; ch++) { 4656 v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir, 4657 p->idx); 4658 if (!(v & HDA_AMP_MUTE) && v > 0) { 4659 if (!check->power_on) { 4660 check->power_on = 1; 4661 snd_hda_power_up(codec); 4662 } 4663 return 1; 4664 } 4665 } 4666 } 4667 if (check->power_on) { 4668 check->power_on = 0; 4669 snd_hda_power_down(codec); 4670 } 4671 return 0; 4672 } 4673 EXPORT_SYMBOL_HDA(snd_hda_check_amp_list_power); 4674 #endif 4675 4676 /* 4677 * Channel mode helper 4678 */ 4679 4680 /** 4681 * snd_hda_ch_mode_info - Info callback helper for the channel mode enum 4682 */ 4683 int snd_hda_ch_mode_info(struct hda_codec *codec, 4684 struct snd_ctl_elem_info *uinfo, 4685 const struct hda_channel_mode *chmode, 4686 int num_chmodes) 4687 { 4688 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 4689 uinfo->count = 1; 4690 uinfo->value.enumerated.items = num_chmodes; 4691 if (uinfo->value.enumerated.item >= num_chmodes) 4692 uinfo->value.enumerated.item = num_chmodes - 1; 4693 sprintf(uinfo->value.enumerated.name, "%dch", 4694 chmode[uinfo->value.enumerated.item].channels); 4695 return 0; 4696 } 4697 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info); 4698 4699 /** 4700 * snd_hda_ch_mode_get - Get callback helper for the channel mode enum 4701 */ 4702 int snd_hda_ch_mode_get(struct hda_codec *codec, 4703 struct snd_ctl_elem_value *ucontrol, 4704 const struct hda_channel_mode *chmode, 4705 int num_chmodes, 4706 int max_channels) 4707 { 4708 int i; 4709 4710 for (i = 0; i < num_chmodes; i++) { 4711 if (max_channels == chmode[i].channels) { 4712 ucontrol->value.enumerated.item[0] = i; 4713 break; 4714 } 4715 } 4716 return 0; 4717 } 4718 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get); 4719 4720 /** 4721 * snd_hda_ch_mode_put - Put callback helper for the channel mode enum 4722 */ 4723 int snd_hda_ch_mode_put(struct hda_codec *codec, 4724 struct snd_ctl_elem_value *ucontrol, 4725 const struct hda_channel_mode *chmode, 4726 int num_chmodes, 4727 int *max_channelsp) 4728 { 4729 unsigned int mode; 4730 4731 mode = ucontrol->value.enumerated.item[0]; 4732 if (mode >= num_chmodes) 4733 return -EINVAL; 4734 if (*max_channelsp == chmode[mode].channels) 4735 return 0; 4736 /* change the current channel setting */ 4737 *max_channelsp = chmode[mode].channels; 4738 if (chmode[mode].sequence) 4739 snd_hda_sequence_write_cache(codec, chmode[mode].sequence); 4740 return 1; 4741 } 4742 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_put); 4743 4744 /* 4745 * input MUX helper 4746 */ 4747 4748 /** 4749 * snd_hda_input_mux_info_info - Info callback helper for the input-mux enum 4750 */ 4751 int snd_hda_input_mux_info(const struct hda_input_mux *imux, 4752 struct snd_ctl_elem_info *uinfo) 4753 { 4754 unsigned int index; 4755 4756 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 4757 uinfo->count = 1; 4758 uinfo->value.enumerated.items = imux->num_items; 4759 if (!imux->num_items) 4760 return 0; 4761 index = uinfo->value.enumerated.item; 4762 if (index >= imux->num_items) 4763 index = imux->num_items - 1; 4764 strcpy(uinfo->value.enumerated.name, imux->items[index].label); 4765 return 0; 4766 } 4767 EXPORT_SYMBOL_HDA(snd_hda_input_mux_info); 4768 4769 /** 4770 * snd_hda_input_mux_info_put - Put callback helper for the input-mux enum 4771 */ 4772 int snd_hda_input_mux_put(struct hda_codec *codec, 4773 const struct hda_input_mux *imux, 4774 struct snd_ctl_elem_value *ucontrol, 4775 hda_nid_t nid, 4776 unsigned int *cur_val) 4777 { 4778 unsigned int idx; 4779 4780 if (!imux->num_items) 4781 return 0; 4782 idx = ucontrol->value.enumerated.item[0]; 4783 if (idx >= imux->num_items) 4784 idx = imux->num_items - 1; 4785 if (*cur_val == idx) 4786 return 0; 4787 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, 4788 imux->items[idx].index); 4789 *cur_val = idx; 4790 return 1; 4791 } 4792 EXPORT_SYMBOL_HDA(snd_hda_input_mux_put); 4793 4794 4795 /* 4796 * process kcontrol info callback of a simple string enum array 4797 * when @num_items is 0 or @texts is NULL, assume a boolean enum array 4798 */ 4799 int snd_hda_enum_helper_info(struct snd_kcontrol *kcontrol, 4800 struct snd_ctl_elem_info *uinfo, 4801 int num_items, const char * const *texts) 4802 { 4803 static const char * const texts_default[] = { 4804 "Disabled", "Enabled" 4805 }; 4806 4807 if (!texts || !num_items) { 4808 num_items = 2; 4809 texts = texts_default; 4810 } 4811 4812 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 4813 uinfo->count = 1; 4814 uinfo->value.enumerated.items = num_items; 4815 if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items) 4816 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1; 4817 strcpy(uinfo->value.enumerated.name, 4818 texts[uinfo->value.enumerated.item]); 4819 return 0; 4820 } 4821 EXPORT_SYMBOL_HDA(snd_hda_enum_helper_info); 4822 4823 /* 4824 * Multi-channel / digital-out PCM helper functions 4825 */ 4826 4827 /* setup SPDIF output stream */ 4828 static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid, 4829 unsigned int stream_tag, unsigned int format) 4830 { 4831 struct hda_spdif_out *spdif; 4832 unsigned int curr_fmt; 4833 bool reset; 4834 4835 spdif = snd_hda_spdif_out_of_nid(codec, nid); 4836 curr_fmt = snd_hda_codec_read(codec, nid, 0, 4837 AC_VERB_GET_STREAM_FORMAT, 0); 4838 reset = codec->spdif_status_reset && 4839 (spdif->ctls & AC_DIG1_ENABLE) && 4840 curr_fmt != format; 4841 4842 /* turn off SPDIF if needed; otherwise the IEC958 bits won't be 4843 updated */ 4844 if (reset) 4845 set_dig_out_convert(codec, nid, 4846 spdif->ctls & ~AC_DIG1_ENABLE & 0xff, 4847 -1); 4848 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format); 4849 if (codec->slave_dig_outs) { 4850 const hda_nid_t *d; 4851 for (d = codec->slave_dig_outs; *d; d++) 4852 snd_hda_codec_setup_stream(codec, *d, stream_tag, 0, 4853 format); 4854 } 4855 /* turn on again (if needed) */ 4856 if (reset) 4857 set_dig_out_convert(codec, nid, 4858 spdif->ctls & 0xff, -1); 4859 } 4860 4861 static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid) 4862 { 4863 snd_hda_codec_cleanup_stream(codec, nid); 4864 if (codec->slave_dig_outs) { 4865 const hda_nid_t *d; 4866 for (d = codec->slave_dig_outs; *d; d++) 4867 snd_hda_codec_cleanup_stream(codec, *d); 4868 } 4869 } 4870 4871 /** 4872 * snd_hda_bus_reboot_notify - call the reboot notifier of each codec 4873 * @bus: HD-audio bus 4874 */ 4875 void snd_hda_bus_reboot_notify(struct hda_bus *bus) 4876 { 4877 struct hda_codec *codec; 4878 4879 if (!bus) 4880 return; 4881 list_for_each_entry(codec, &bus->codec_list, list) { 4882 if (hda_codec_is_power_on(codec) && 4883 codec->patch_ops.reboot_notify) 4884 codec->patch_ops.reboot_notify(codec); 4885 } 4886 } 4887 EXPORT_SYMBOL_HDA(snd_hda_bus_reboot_notify); 4888 4889 /** 4890 * snd_hda_multi_out_dig_open - open the digital out in the exclusive mode 4891 */ 4892 int snd_hda_multi_out_dig_open(struct hda_codec *codec, 4893 struct hda_multi_out *mout) 4894 { 4895 mutex_lock(&codec->spdif_mutex); 4896 if (mout->dig_out_used == HDA_DIG_ANALOG_DUP) 4897 /* already opened as analog dup; reset it once */ 4898 cleanup_dig_out_stream(codec, mout->dig_out_nid); 4899 mout->dig_out_used = HDA_DIG_EXCLUSIVE; 4900 mutex_unlock(&codec->spdif_mutex); 4901 return 0; 4902 } 4903 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_open); 4904 4905 /** 4906 * snd_hda_multi_out_dig_prepare - prepare the digital out stream 4907 */ 4908 int snd_hda_multi_out_dig_prepare(struct hda_codec *codec, 4909 struct hda_multi_out *mout, 4910 unsigned int stream_tag, 4911 unsigned int format, 4912 struct snd_pcm_substream *substream) 4913 { 4914 mutex_lock(&codec->spdif_mutex); 4915 setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format); 4916 mutex_unlock(&codec->spdif_mutex); 4917 return 0; 4918 } 4919 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare); 4920 4921 /** 4922 * snd_hda_multi_out_dig_cleanup - clean-up the digital out stream 4923 */ 4924 int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec, 4925 struct hda_multi_out *mout) 4926 { 4927 mutex_lock(&codec->spdif_mutex); 4928 cleanup_dig_out_stream(codec, mout->dig_out_nid); 4929 mutex_unlock(&codec->spdif_mutex); 4930 return 0; 4931 } 4932 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_cleanup); 4933 4934 /** 4935 * snd_hda_multi_out_dig_close - release the digital out stream 4936 */ 4937 int snd_hda_multi_out_dig_close(struct hda_codec *codec, 4938 struct hda_multi_out *mout) 4939 { 4940 mutex_lock(&codec->spdif_mutex); 4941 mout->dig_out_used = 0; 4942 mutex_unlock(&codec->spdif_mutex); 4943 return 0; 4944 } 4945 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_close); 4946 4947 /** 4948 * snd_hda_multi_out_analog_open - open analog outputs 4949 * 4950 * Open analog outputs and set up the hw-constraints. 4951 * If the digital outputs can be opened as slave, open the digital 4952 * outputs, too. 4953 */ 4954 int snd_hda_multi_out_analog_open(struct hda_codec *codec, 4955 struct hda_multi_out *mout, 4956 struct snd_pcm_substream *substream, 4957 struct hda_pcm_stream *hinfo) 4958 { 4959 struct snd_pcm_runtime *runtime = substream->runtime; 4960 runtime->hw.channels_max = mout->max_channels; 4961 if (mout->dig_out_nid) { 4962 if (!mout->analog_rates) { 4963 mout->analog_rates = hinfo->rates; 4964 mout->analog_formats = hinfo->formats; 4965 mout->analog_maxbps = hinfo->maxbps; 4966 } else { 4967 runtime->hw.rates = mout->analog_rates; 4968 runtime->hw.formats = mout->analog_formats; 4969 hinfo->maxbps = mout->analog_maxbps; 4970 } 4971 if (!mout->spdif_rates) { 4972 snd_hda_query_supported_pcm(codec, mout->dig_out_nid, 4973 &mout->spdif_rates, 4974 &mout->spdif_formats, 4975 &mout->spdif_maxbps); 4976 } 4977 mutex_lock(&codec->spdif_mutex); 4978 if (mout->share_spdif) { 4979 if ((runtime->hw.rates & mout->spdif_rates) && 4980 (runtime->hw.formats & mout->spdif_formats)) { 4981 runtime->hw.rates &= mout->spdif_rates; 4982 runtime->hw.formats &= mout->spdif_formats; 4983 if (mout->spdif_maxbps < hinfo->maxbps) 4984 hinfo->maxbps = mout->spdif_maxbps; 4985 } else { 4986 mout->share_spdif = 0; 4987 /* FIXME: need notify? */ 4988 } 4989 } 4990 mutex_unlock(&codec->spdif_mutex); 4991 } 4992 return snd_pcm_hw_constraint_step(substream->runtime, 0, 4993 SNDRV_PCM_HW_PARAM_CHANNELS, 2); 4994 } 4995 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_open); 4996 4997 /** 4998 * snd_hda_multi_out_analog_prepare - Preapre the analog outputs. 4999 * 5000 * Set up the i/o for analog out. 5001 * When the digital out is available, copy the front out to digital out, too. 5002 */ 5003 int snd_hda_multi_out_analog_prepare(struct hda_codec *codec, 5004 struct hda_multi_out *mout, 5005 unsigned int stream_tag, 5006 unsigned int format, 5007 struct snd_pcm_substream *substream) 5008 { 5009 const hda_nid_t *nids = mout->dac_nids; 5010 int chs = substream->runtime->channels; 5011 struct hda_spdif_out *spdif; 5012 int i; 5013 5014 mutex_lock(&codec->spdif_mutex); 5015 spdif = snd_hda_spdif_out_of_nid(codec, mout->dig_out_nid); 5016 if (mout->dig_out_nid && mout->share_spdif && 5017 mout->dig_out_used != HDA_DIG_EXCLUSIVE) { 5018 if (chs == 2 && 5019 snd_hda_is_supported_format(codec, mout->dig_out_nid, 5020 format) && 5021 !(spdif->status & IEC958_AES0_NONAUDIO)) { 5022 mout->dig_out_used = HDA_DIG_ANALOG_DUP; 5023 setup_dig_out_stream(codec, mout->dig_out_nid, 5024 stream_tag, format); 5025 } else { 5026 mout->dig_out_used = 0; 5027 cleanup_dig_out_stream(codec, mout->dig_out_nid); 5028 } 5029 } 5030 mutex_unlock(&codec->spdif_mutex); 5031 5032 /* front */ 5033 snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag, 5034 0, format); 5035 if (!mout->no_share_stream && 5036 mout->hp_nid && mout->hp_nid != nids[HDA_FRONT]) 5037 /* headphone out will just decode front left/right (stereo) */ 5038 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag, 5039 0, format); 5040 /* extra outputs copied from front */ 5041 for (i = 0; i < ARRAY_SIZE(mout->hp_out_nid); i++) 5042 if (!mout->no_share_stream && mout->hp_out_nid[i]) 5043 snd_hda_codec_setup_stream(codec, 5044 mout->hp_out_nid[i], 5045 stream_tag, 0, format); 5046 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++) 5047 if (!mout->no_share_stream && mout->extra_out_nid[i]) 5048 snd_hda_codec_setup_stream(codec, 5049 mout->extra_out_nid[i], 5050 stream_tag, 0, format); 5051 5052 /* surrounds */ 5053 for (i = 1; i < mout->num_dacs; i++) { 5054 if (chs >= (i + 1) * 2) /* independent out */ 5055 snd_hda_codec_setup_stream(codec, nids[i], stream_tag, 5056 i * 2, format); 5057 else if (!mout->no_share_stream) /* copy front */ 5058 snd_hda_codec_setup_stream(codec, nids[i], stream_tag, 5059 0, format); 5060 } 5061 return 0; 5062 } 5063 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_prepare); 5064 5065 /** 5066 * snd_hda_multi_out_analog_cleanup - clean up the setting for analog out 5067 */ 5068 int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec, 5069 struct hda_multi_out *mout) 5070 { 5071 const hda_nid_t *nids = mout->dac_nids; 5072 int i; 5073 5074 for (i = 0; i < mout->num_dacs; i++) 5075 snd_hda_codec_cleanup_stream(codec, nids[i]); 5076 if (mout->hp_nid) 5077 snd_hda_codec_cleanup_stream(codec, mout->hp_nid); 5078 for (i = 0; i < ARRAY_SIZE(mout->hp_out_nid); i++) 5079 if (mout->hp_out_nid[i]) 5080 snd_hda_codec_cleanup_stream(codec, 5081 mout->hp_out_nid[i]); 5082 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++) 5083 if (mout->extra_out_nid[i]) 5084 snd_hda_codec_cleanup_stream(codec, 5085 mout->extra_out_nid[i]); 5086 mutex_lock(&codec->spdif_mutex); 5087 if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) { 5088 cleanup_dig_out_stream(codec, mout->dig_out_nid); 5089 mout->dig_out_used = 0; 5090 } 5091 mutex_unlock(&codec->spdif_mutex); 5092 return 0; 5093 } 5094 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_cleanup); 5095 5096 /** 5097 * snd_hda_get_default_vref - Get the default (mic) VREF pin bits 5098 * 5099 * Guess the suitable VREF pin bits to be set as the pin-control value. 5100 * Note: the function doesn't set the AC_PINCTL_IN_EN bit. 5101 */ 5102 unsigned int snd_hda_get_default_vref(struct hda_codec *codec, hda_nid_t pin) 5103 { 5104 unsigned int pincap; 5105 unsigned int oldval; 5106 oldval = snd_hda_codec_read(codec, pin, 0, 5107 AC_VERB_GET_PIN_WIDGET_CONTROL, 0); 5108 pincap = snd_hda_query_pin_caps(codec, pin); 5109 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT; 5110 /* Exception: if the default pin setup is vref50, we give it priority */ 5111 if ((pincap & AC_PINCAP_VREF_80) && oldval != PIN_VREF50) 5112 return AC_PINCTL_VREF_80; 5113 else if (pincap & AC_PINCAP_VREF_50) 5114 return AC_PINCTL_VREF_50; 5115 else if (pincap & AC_PINCAP_VREF_100) 5116 return AC_PINCTL_VREF_100; 5117 else if (pincap & AC_PINCAP_VREF_GRD) 5118 return AC_PINCTL_VREF_GRD; 5119 return AC_PINCTL_VREF_HIZ; 5120 } 5121 EXPORT_SYMBOL_HDA(snd_hda_get_default_vref); 5122 5123 int _snd_hda_set_pin_ctl(struct hda_codec *codec, hda_nid_t pin, 5124 unsigned int val, bool cached) 5125 { 5126 if (val) { 5127 unsigned int cap = snd_hda_query_pin_caps(codec, pin); 5128 if (cap && (val & AC_PINCTL_OUT_EN)) { 5129 if (!(cap & AC_PINCAP_OUT)) 5130 val &= ~(AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN); 5131 else if ((val & AC_PINCTL_HP_EN) && 5132 !(cap & AC_PINCAP_HP_DRV)) 5133 val &= ~AC_PINCTL_HP_EN; 5134 } 5135 if (cap && (val & AC_PINCTL_IN_EN)) { 5136 if (!(cap & AC_PINCAP_IN)) 5137 val &= ~(AC_PINCTL_IN_EN | AC_PINCTL_VREFEN); 5138 } 5139 } 5140 if (cached) 5141 return snd_hda_codec_update_cache(codec, pin, 0, 5142 AC_VERB_SET_PIN_WIDGET_CONTROL, val); 5143 else 5144 return snd_hda_codec_write(codec, pin, 0, 5145 AC_VERB_SET_PIN_WIDGET_CONTROL, val); 5146 } 5147 EXPORT_SYMBOL_HDA(_snd_hda_set_pin_ctl); 5148 5149 /** 5150 * snd_hda_add_imux_item - Add an item to input_mux 5151 * 5152 * When the same label is used already in the existing items, the number 5153 * suffix is appended to the label. This label index number is stored 5154 * to type_idx when non-NULL pointer is given. 5155 */ 5156 int snd_hda_add_imux_item(struct hda_input_mux *imux, const char *label, 5157 int index, int *type_idx) 5158 { 5159 int i, label_idx = 0; 5160 if (imux->num_items >= HDA_MAX_NUM_INPUTS) { 5161 snd_printd(KERN_ERR "hda_codec: Too many imux items!\n"); 5162 return -EINVAL; 5163 } 5164 for (i = 0; i < imux->num_items; i++) { 5165 if (!strncmp(label, imux->items[i].label, strlen(label))) 5166 label_idx++; 5167 } 5168 if (type_idx) 5169 *type_idx = label_idx; 5170 if (label_idx > 0) 5171 snprintf(imux->items[imux->num_items].label, 5172 sizeof(imux->items[imux->num_items].label), 5173 "%s %d", label, label_idx); 5174 else 5175 strlcpy(imux->items[imux->num_items].label, label, 5176 sizeof(imux->items[imux->num_items].label)); 5177 imux->items[imux->num_items].index = index; 5178 imux->num_items++; 5179 return 0; 5180 } 5181 EXPORT_SYMBOL_HDA(snd_hda_add_imux_item); 5182 5183 5184 #ifdef CONFIG_PM 5185 /* 5186 * power management 5187 */ 5188 5189 /** 5190 * snd_hda_suspend - suspend the codecs 5191 * @bus: the HDA bus 5192 * 5193 * Returns 0 if successful. 5194 */ 5195 int snd_hda_suspend(struct hda_bus *bus) 5196 { 5197 struct hda_codec *codec; 5198 5199 list_for_each_entry(codec, &bus->codec_list, list) { 5200 cancel_delayed_work_sync(&codec->jackpoll_work); 5201 if (hda_codec_is_power_on(codec)) 5202 hda_call_codec_suspend(codec, false); 5203 } 5204 return 0; 5205 } 5206 EXPORT_SYMBOL_HDA(snd_hda_suspend); 5207 5208 /** 5209 * snd_hda_resume - resume the codecs 5210 * @bus: the HDA bus 5211 * 5212 * Returns 0 if successful. 5213 */ 5214 int snd_hda_resume(struct hda_bus *bus) 5215 { 5216 struct hda_codec *codec; 5217 5218 list_for_each_entry(codec, &bus->codec_list, list) { 5219 hda_call_codec_resume(codec); 5220 } 5221 return 0; 5222 } 5223 EXPORT_SYMBOL_HDA(snd_hda_resume); 5224 #endif /* CONFIG_PM */ 5225 5226 /* 5227 * generic arrays 5228 */ 5229 5230 /** 5231 * snd_array_new - get a new element from the given array 5232 * @array: the array object 5233 * 5234 * Get a new element from the given array. If it exceeds the 5235 * pre-allocated array size, re-allocate the array. 5236 * 5237 * Returns NULL if allocation failed. 5238 */ 5239 void *snd_array_new(struct snd_array *array) 5240 { 5241 if (snd_BUG_ON(!array->elem_size)) 5242 return NULL; 5243 if (array->used >= array->alloced) { 5244 int num = array->alloced + array->alloc_align; 5245 int size = (num + 1) * array->elem_size; 5246 int oldsize = array->alloced * array->elem_size; 5247 void *nlist; 5248 if (snd_BUG_ON(num >= 4096)) 5249 return NULL; 5250 nlist = krealloc(array->list, size, GFP_KERNEL); 5251 if (!nlist) 5252 return NULL; 5253 memset(nlist + oldsize, 0, size - oldsize); 5254 array->list = nlist; 5255 array->alloced = num; 5256 } 5257 return snd_array_elem(array, array->used++); 5258 } 5259 EXPORT_SYMBOL_HDA(snd_array_new); 5260 5261 /** 5262 * snd_array_free - free the given array elements 5263 * @array: the array object 5264 */ 5265 void snd_array_free(struct snd_array *array) 5266 { 5267 kfree(array->list); 5268 array->used = 0; 5269 array->alloced = 0; 5270 array->list = NULL; 5271 } 5272 EXPORT_SYMBOL_HDA(snd_array_free); 5273 5274 /** 5275 * snd_print_pcm_bits - Print the supported PCM fmt bits to the string buffer 5276 * @pcm: PCM caps bits 5277 * @buf: the string buffer to write 5278 * @buflen: the max buffer length 5279 * 5280 * used by hda_proc.c and hda_eld.c 5281 */ 5282 void snd_print_pcm_bits(int pcm, char *buf, int buflen) 5283 { 5284 static unsigned int bits[] = { 8, 16, 20, 24, 32 }; 5285 int i, j; 5286 5287 for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++) 5288 if (pcm & (AC_SUPPCM_BITS_8 << i)) 5289 j += snprintf(buf + j, buflen - j, " %d", bits[i]); 5290 5291 buf[j] = '\0'; /* necessary when j == 0 */ 5292 } 5293 EXPORT_SYMBOL_HDA(snd_print_pcm_bits); 5294 5295 MODULE_DESCRIPTION("HDA codec core"); 5296 MODULE_LICENSE("GPL"); 5297