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