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 "hda_local.h" 33 #include <sound/hda_hwdep.h> 34 #include "hda_patch.h" /* codec presets */ 35 36 #ifdef CONFIG_SND_HDA_POWER_SAVE 37 /* define this option here to hide as static */ 38 static int power_save = CONFIG_SND_HDA_POWER_SAVE_DEFAULT; 39 module_param(power_save, int, 0644); 40 MODULE_PARM_DESC(power_save, "Automatic power-saving timeout " 41 "(in second, 0 = disable)."); 42 #endif 43 44 /* 45 * vendor / preset table 46 */ 47 48 struct hda_vendor_id { 49 unsigned int id; 50 const char *name; 51 }; 52 53 /* codec vendor labels */ 54 static struct hda_vendor_id hda_vendor_ids[] = { 55 { 0x1002, "ATI" }, 56 { 0x1057, "Motorola" }, 57 { 0x1095, "Silicon Image" }, 58 { 0x10ec, "Realtek" }, 59 { 0x1106, "VIA" }, 60 { 0x111d, "IDT" }, 61 { 0x11c1, "LSI" }, 62 { 0x11d4, "Analog Devices" }, 63 { 0x13f6, "C-Media" }, 64 { 0x14f1, "Conexant" }, 65 { 0x17e8, "Chrontel" }, 66 { 0x1854, "LG" }, 67 { 0x434d, "C-Media" }, 68 { 0x8384, "SigmaTel" }, 69 {} /* terminator */ 70 }; 71 72 static const struct hda_codec_preset *hda_preset_tables[] = { 73 #ifdef CONFIG_SND_HDA_CODEC_REALTEK 74 snd_hda_preset_realtek, 75 #endif 76 #ifdef CONFIG_SND_HDA_CODEC_CMEDIA 77 snd_hda_preset_cmedia, 78 #endif 79 #ifdef CONFIG_SND_HDA_CODEC_ANALOG 80 snd_hda_preset_analog, 81 #endif 82 #ifdef CONFIG_SND_HDA_CODEC_SIGMATEL 83 snd_hda_preset_sigmatel, 84 #endif 85 #ifdef CONFIG_SND_HDA_CODEC_SI3054 86 snd_hda_preset_si3054, 87 #endif 88 #ifdef CONFIG_SND_HDA_CODEC_ATIHDMI 89 snd_hda_preset_atihdmi, 90 #endif 91 #ifdef CONFIG_SND_HDA_CODEC_CONEXANT 92 snd_hda_preset_conexant, 93 #endif 94 #ifdef CONFIG_SND_HDA_CODEC_VIA 95 snd_hda_preset_via, 96 #endif 97 NULL 98 }; 99 100 #ifdef CONFIG_SND_HDA_POWER_SAVE 101 static void hda_power_work(struct work_struct *work); 102 static void hda_keep_power_on(struct hda_codec *codec); 103 #else 104 static inline void hda_keep_power_on(struct hda_codec *codec) {} 105 #endif 106 107 /** 108 * snd_hda_codec_read - send a command and get the response 109 * @codec: the HDA codec 110 * @nid: NID to send the command 111 * @direct: direct flag 112 * @verb: the verb to send 113 * @parm: the parameter for the verb 114 * 115 * Send a single command and read the corresponding response. 116 * 117 * Returns the obtained response value, or -1 for an error. 118 */ 119 unsigned int snd_hda_codec_read(struct hda_codec *codec, hda_nid_t nid, 120 int direct, 121 unsigned int verb, unsigned int parm) 122 { 123 unsigned int res; 124 snd_hda_power_up(codec); 125 mutex_lock(&codec->bus->cmd_mutex); 126 if (!codec->bus->ops.command(codec, nid, direct, verb, parm)) 127 res = codec->bus->ops.get_response(codec); 128 else 129 res = (unsigned int)-1; 130 mutex_unlock(&codec->bus->cmd_mutex); 131 snd_hda_power_down(codec); 132 return res; 133 } 134 135 /** 136 * snd_hda_codec_write - send a single command without waiting for response 137 * @codec: the HDA codec 138 * @nid: NID to send the command 139 * @direct: direct flag 140 * @verb: the verb to send 141 * @parm: the parameter for the verb 142 * 143 * Send a single command without waiting for response. 144 * 145 * Returns 0 if successful, or a negative error code. 146 */ 147 int snd_hda_codec_write(struct hda_codec *codec, hda_nid_t nid, int direct, 148 unsigned int verb, unsigned int parm) 149 { 150 int err; 151 snd_hda_power_up(codec); 152 mutex_lock(&codec->bus->cmd_mutex); 153 err = codec->bus->ops.command(codec, nid, direct, verb, parm); 154 mutex_unlock(&codec->bus->cmd_mutex); 155 snd_hda_power_down(codec); 156 return err; 157 } 158 159 /** 160 * snd_hda_sequence_write - sequence writes 161 * @codec: the HDA codec 162 * @seq: VERB array to send 163 * 164 * Send the commands sequentially from the given array. 165 * The array must be terminated with NID=0. 166 */ 167 void snd_hda_sequence_write(struct hda_codec *codec, const struct hda_verb *seq) 168 { 169 for (; seq->nid; seq++) 170 snd_hda_codec_write(codec, seq->nid, 0, seq->verb, seq->param); 171 } 172 173 /** 174 * snd_hda_get_sub_nodes - get the range of sub nodes 175 * @codec: the HDA codec 176 * @nid: NID to parse 177 * @start_id: the pointer to store the start NID 178 * 179 * Parse the NID and store the start NID of its sub-nodes. 180 * Returns the number of sub-nodes. 181 */ 182 int snd_hda_get_sub_nodes(struct hda_codec *codec, hda_nid_t nid, 183 hda_nid_t *start_id) 184 { 185 unsigned int parm; 186 187 parm = snd_hda_param_read(codec, nid, AC_PAR_NODE_COUNT); 188 if (parm == -1) 189 return 0; 190 *start_id = (parm >> 16) & 0x7fff; 191 return (int)(parm & 0x7fff); 192 } 193 194 /** 195 * snd_hda_get_connections - get connection list 196 * @codec: the HDA codec 197 * @nid: NID to parse 198 * @conn_list: connection list array 199 * @max_conns: max. number of connections to store 200 * 201 * Parses the connection list of the given widget and stores the list 202 * of NIDs. 203 * 204 * Returns the number of connections, or a negative error code. 205 */ 206 int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid, 207 hda_nid_t *conn_list, int max_conns) 208 { 209 unsigned int parm; 210 int i, conn_len, conns; 211 unsigned int shift, num_elems, mask; 212 hda_nid_t prev_nid; 213 214 snd_assert(conn_list && max_conns > 0, return -EINVAL); 215 216 parm = snd_hda_param_read(codec, nid, AC_PAR_CONNLIST_LEN); 217 if (parm & AC_CLIST_LONG) { 218 /* long form */ 219 shift = 16; 220 num_elems = 2; 221 } else { 222 /* short form */ 223 shift = 8; 224 num_elems = 4; 225 } 226 conn_len = parm & AC_CLIST_LENGTH; 227 mask = (1 << (shift-1)) - 1; 228 229 if (!conn_len) 230 return 0; /* no connection */ 231 232 if (conn_len == 1) { 233 /* single connection */ 234 parm = snd_hda_codec_read(codec, nid, 0, 235 AC_VERB_GET_CONNECT_LIST, 0); 236 conn_list[0] = parm & mask; 237 return 1; 238 } 239 240 /* multi connection */ 241 conns = 0; 242 prev_nid = 0; 243 for (i = 0; i < conn_len; i++) { 244 int range_val; 245 hda_nid_t val, n; 246 247 if (i % num_elems == 0) 248 parm = snd_hda_codec_read(codec, nid, 0, 249 AC_VERB_GET_CONNECT_LIST, i); 250 range_val = !!(parm & (1 << (shift-1))); /* ranges */ 251 val = parm & mask; 252 parm >>= shift; 253 if (range_val) { 254 /* ranges between the previous and this one */ 255 if (!prev_nid || prev_nid >= val) { 256 snd_printk(KERN_WARNING "hda_codec: " 257 "invalid dep_range_val %x:%x\n", 258 prev_nid, val); 259 continue; 260 } 261 for (n = prev_nid + 1; n <= val; n++) { 262 if (conns >= max_conns) { 263 snd_printk(KERN_ERR 264 "Too many connections\n"); 265 return -EINVAL; 266 } 267 conn_list[conns++] = n; 268 } 269 } else { 270 if (conns >= max_conns) { 271 snd_printk(KERN_ERR "Too many connections\n"); 272 return -EINVAL; 273 } 274 conn_list[conns++] = val; 275 } 276 prev_nid = val; 277 } 278 return conns; 279 } 280 281 282 /** 283 * snd_hda_queue_unsol_event - add an unsolicited event to queue 284 * @bus: the BUS 285 * @res: unsolicited event (lower 32bit of RIRB entry) 286 * @res_ex: codec addr and flags (upper 32bit or RIRB entry) 287 * 288 * Adds the given event to the queue. The events are processed in 289 * the workqueue asynchronously. Call this function in the interrupt 290 * hanlder when RIRB receives an unsolicited event. 291 * 292 * Returns 0 if successful, or a negative error code. 293 */ 294 int snd_hda_queue_unsol_event(struct hda_bus *bus, u32 res, u32 res_ex) 295 { 296 struct hda_bus_unsolicited *unsol; 297 unsigned int wp; 298 299 unsol = bus->unsol; 300 if (!unsol) 301 return 0; 302 303 wp = (unsol->wp + 1) % HDA_UNSOL_QUEUE_SIZE; 304 unsol->wp = wp; 305 306 wp <<= 1; 307 unsol->queue[wp] = res; 308 unsol->queue[wp + 1] = res_ex; 309 310 schedule_work(&unsol->work); 311 312 return 0; 313 } 314 315 /* 316 * process queueud unsolicited events 317 */ 318 static void process_unsol_events(struct work_struct *work) 319 { 320 struct hda_bus_unsolicited *unsol = 321 container_of(work, struct hda_bus_unsolicited, work); 322 struct hda_bus *bus = unsol->bus; 323 struct hda_codec *codec; 324 unsigned int rp, caddr, res; 325 326 while (unsol->rp != unsol->wp) { 327 rp = (unsol->rp + 1) % HDA_UNSOL_QUEUE_SIZE; 328 unsol->rp = rp; 329 rp <<= 1; 330 res = unsol->queue[rp]; 331 caddr = unsol->queue[rp + 1]; 332 if (!(caddr & (1 << 4))) /* no unsolicited event? */ 333 continue; 334 codec = bus->caddr_tbl[caddr & 0x0f]; 335 if (codec && codec->patch_ops.unsol_event) 336 codec->patch_ops.unsol_event(codec, res); 337 } 338 } 339 340 /* 341 * initialize unsolicited queue 342 */ 343 static int __devinit init_unsol_queue(struct hda_bus *bus) 344 { 345 struct hda_bus_unsolicited *unsol; 346 347 if (bus->unsol) /* already initialized */ 348 return 0; 349 350 unsol = kzalloc(sizeof(*unsol), GFP_KERNEL); 351 if (!unsol) { 352 snd_printk(KERN_ERR "hda_codec: " 353 "can't allocate unsolicited queue\n"); 354 return -ENOMEM; 355 } 356 INIT_WORK(&unsol->work, process_unsol_events); 357 unsol->bus = bus; 358 bus->unsol = unsol; 359 return 0; 360 } 361 362 /* 363 * destructor 364 */ 365 static void snd_hda_codec_free(struct hda_codec *codec); 366 367 static int snd_hda_bus_free(struct hda_bus *bus) 368 { 369 struct hda_codec *codec, *n; 370 371 if (!bus) 372 return 0; 373 if (bus->unsol) { 374 flush_scheduled_work(); 375 kfree(bus->unsol); 376 } 377 list_for_each_entry_safe(codec, n, &bus->codec_list, list) { 378 snd_hda_codec_free(codec); 379 } 380 if (bus->ops.private_free) 381 bus->ops.private_free(bus); 382 kfree(bus); 383 return 0; 384 } 385 386 static int snd_hda_bus_dev_free(struct snd_device *device) 387 { 388 struct hda_bus *bus = device->device_data; 389 return snd_hda_bus_free(bus); 390 } 391 392 /** 393 * snd_hda_bus_new - create a HDA bus 394 * @card: the card entry 395 * @temp: the template for hda_bus information 396 * @busp: the pointer to store the created bus instance 397 * 398 * Returns 0 if successful, or a negative error code. 399 */ 400 int __devinit snd_hda_bus_new(struct snd_card *card, 401 const struct hda_bus_template *temp, 402 struct hda_bus **busp) 403 { 404 struct hda_bus *bus; 405 int err; 406 static struct snd_device_ops dev_ops = { 407 .dev_free = snd_hda_bus_dev_free, 408 }; 409 410 snd_assert(temp, return -EINVAL); 411 snd_assert(temp->ops.command && temp->ops.get_response, return -EINVAL); 412 413 if (busp) 414 *busp = NULL; 415 416 bus = kzalloc(sizeof(*bus), GFP_KERNEL); 417 if (bus == NULL) { 418 snd_printk(KERN_ERR "can't allocate struct hda_bus\n"); 419 return -ENOMEM; 420 } 421 422 bus->card = card; 423 bus->private_data = temp->private_data; 424 bus->pci = temp->pci; 425 bus->modelname = temp->modelname; 426 bus->ops = temp->ops; 427 428 mutex_init(&bus->cmd_mutex); 429 INIT_LIST_HEAD(&bus->codec_list); 430 431 err = snd_device_new(card, SNDRV_DEV_BUS, bus, &dev_ops); 432 if (err < 0) { 433 snd_hda_bus_free(bus); 434 return err; 435 } 436 if (busp) 437 *busp = bus; 438 return 0; 439 } 440 441 #ifdef CONFIG_SND_HDA_GENERIC 442 #define is_generic_config(codec) \ 443 (codec->bus->modelname && !strcmp(codec->bus->modelname, "generic")) 444 #else 445 #define is_generic_config(codec) 0 446 #endif 447 448 /* 449 * find a matching codec preset 450 */ 451 static const struct hda_codec_preset __devinit * 452 find_codec_preset(struct hda_codec *codec) 453 { 454 const struct hda_codec_preset **tbl, *preset; 455 456 if (is_generic_config(codec)) 457 return NULL; /* use the generic parser */ 458 459 for (tbl = hda_preset_tables; *tbl; tbl++) { 460 for (preset = *tbl; preset->id; preset++) { 461 u32 mask = preset->mask; 462 if (preset->afg && preset->afg != codec->afg) 463 continue; 464 if (preset->mfg && preset->mfg != codec->mfg) 465 continue; 466 if (!mask) 467 mask = ~0; 468 if (preset->id == (codec->vendor_id & mask) && 469 (!preset->rev || 470 preset->rev == codec->revision_id)) 471 return preset; 472 } 473 } 474 return NULL; 475 } 476 477 /* 478 * snd_hda_get_codec_name - store the codec name 479 */ 480 void snd_hda_get_codec_name(struct hda_codec *codec, 481 char *name, int namelen) 482 { 483 const struct hda_vendor_id *c; 484 const char *vendor = NULL; 485 u16 vendor_id = codec->vendor_id >> 16; 486 char tmp[16]; 487 488 for (c = hda_vendor_ids; c->id; c++) { 489 if (c->id == vendor_id) { 490 vendor = c->name; 491 break; 492 } 493 } 494 if (!vendor) { 495 sprintf(tmp, "Generic %04x", vendor_id); 496 vendor = tmp; 497 } 498 if (codec->preset && codec->preset->name) 499 snprintf(name, namelen, "%s %s", vendor, codec->preset->name); 500 else 501 snprintf(name, namelen, "%s ID %x", vendor, 502 codec->vendor_id & 0xffff); 503 } 504 505 /* 506 * look for an AFG and MFG nodes 507 */ 508 static void __devinit setup_fg_nodes(struct hda_codec *codec) 509 { 510 int i, total_nodes; 511 hda_nid_t nid; 512 513 total_nodes = snd_hda_get_sub_nodes(codec, AC_NODE_ROOT, &nid); 514 for (i = 0; i < total_nodes; i++, nid++) { 515 unsigned int func; 516 func = snd_hda_param_read(codec, nid, AC_PAR_FUNCTION_TYPE); 517 switch (func & 0xff) { 518 case AC_GRP_AUDIO_FUNCTION: 519 codec->afg = nid; 520 break; 521 case AC_GRP_MODEM_FUNCTION: 522 codec->mfg = nid; 523 break; 524 default: 525 break; 526 } 527 } 528 } 529 530 /* 531 * read widget caps for each widget and store in cache 532 */ 533 static int read_widget_caps(struct hda_codec *codec, hda_nid_t fg_node) 534 { 535 int i; 536 hda_nid_t nid; 537 538 codec->num_nodes = snd_hda_get_sub_nodes(codec, fg_node, 539 &codec->start_nid); 540 codec->wcaps = kmalloc(codec->num_nodes * 4, GFP_KERNEL); 541 if (!codec->wcaps) 542 return -ENOMEM; 543 nid = codec->start_nid; 544 for (i = 0; i < codec->num_nodes; i++, nid++) 545 codec->wcaps[i] = snd_hda_param_read(codec, nid, 546 AC_PAR_AUDIO_WIDGET_CAP); 547 return 0; 548 } 549 550 551 static void init_hda_cache(struct hda_cache_rec *cache, 552 unsigned int record_size); 553 static void free_hda_cache(struct hda_cache_rec *cache); 554 555 /* 556 * codec destructor 557 */ 558 static void snd_hda_codec_free(struct hda_codec *codec) 559 { 560 if (!codec) 561 return; 562 #ifdef CONFIG_SND_HDA_POWER_SAVE 563 cancel_delayed_work(&codec->power_work); 564 flush_scheduled_work(); 565 #endif 566 list_del(&codec->list); 567 codec->bus->caddr_tbl[codec->addr] = NULL; 568 if (codec->patch_ops.free) 569 codec->patch_ops.free(codec); 570 free_hda_cache(&codec->amp_cache); 571 free_hda_cache(&codec->cmd_cache); 572 kfree(codec->wcaps); 573 kfree(codec); 574 } 575 576 /** 577 * snd_hda_codec_new - create a HDA codec 578 * @bus: the bus to assign 579 * @codec_addr: the codec address 580 * @codecp: the pointer to store the generated codec 581 * 582 * Returns 0 if successful, or a negative error code. 583 */ 584 int __devinit snd_hda_codec_new(struct hda_bus *bus, unsigned int codec_addr, 585 struct hda_codec **codecp) 586 { 587 struct hda_codec *codec; 588 char component[13]; 589 int err; 590 591 snd_assert(bus, return -EINVAL); 592 snd_assert(codec_addr <= HDA_MAX_CODEC_ADDRESS, return -EINVAL); 593 594 if (bus->caddr_tbl[codec_addr]) { 595 snd_printk(KERN_ERR "hda_codec: " 596 "address 0x%x is already occupied\n", codec_addr); 597 return -EBUSY; 598 } 599 600 codec = kzalloc(sizeof(*codec), GFP_KERNEL); 601 if (codec == NULL) { 602 snd_printk(KERN_ERR "can't allocate struct hda_codec\n"); 603 return -ENOMEM; 604 } 605 606 codec->bus = bus; 607 codec->addr = codec_addr; 608 mutex_init(&codec->spdif_mutex); 609 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info)); 610 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head)); 611 612 #ifdef CONFIG_SND_HDA_POWER_SAVE 613 INIT_DELAYED_WORK(&codec->power_work, hda_power_work); 614 /* snd_hda_codec_new() marks the codec as power-up, and leave it as is. 615 * the caller has to power down appropriatley after initialization 616 * phase. 617 */ 618 hda_keep_power_on(codec); 619 #endif 620 621 list_add_tail(&codec->list, &bus->codec_list); 622 bus->caddr_tbl[codec_addr] = codec; 623 624 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT, 625 AC_PAR_VENDOR_ID); 626 if (codec->vendor_id == -1) 627 /* read again, hopefully the access method was corrected 628 * in the last read... 629 */ 630 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT, 631 AC_PAR_VENDOR_ID); 632 codec->subsystem_id = snd_hda_param_read(codec, AC_NODE_ROOT, 633 AC_PAR_SUBSYSTEM_ID); 634 codec->revision_id = snd_hda_param_read(codec, AC_NODE_ROOT, 635 AC_PAR_REV_ID); 636 637 setup_fg_nodes(codec); 638 if (!codec->afg && !codec->mfg) { 639 snd_printdd("hda_codec: no AFG or MFG node found\n"); 640 snd_hda_codec_free(codec); 641 return -ENODEV; 642 } 643 644 if (read_widget_caps(codec, codec->afg ? codec->afg : codec->mfg) < 0) { 645 snd_printk(KERN_ERR "hda_codec: cannot malloc\n"); 646 snd_hda_codec_free(codec); 647 return -ENOMEM; 648 } 649 650 if (!codec->subsystem_id) { 651 hda_nid_t nid = codec->afg ? codec->afg : codec->mfg; 652 codec->subsystem_id = 653 snd_hda_codec_read(codec, nid, 0, 654 AC_VERB_GET_SUBSYSTEM_ID, 0); 655 } 656 657 codec->preset = find_codec_preset(codec); 658 /* audio codec should override the mixer name */ 659 if (codec->afg || !*bus->card->mixername) 660 snd_hda_get_codec_name(codec, bus->card->mixername, 661 sizeof(bus->card->mixername)); 662 663 if (is_generic_config(codec)) { 664 err = snd_hda_parse_generic_codec(codec); 665 goto patched; 666 } 667 if (codec->preset && codec->preset->patch) { 668 err = codec->preset->patch(codec); 669 goto patched; 670 } 671 672 /* call the default parser */ 673 err = snd_hda_parse_generic_codec(codec); 674 if (err < 0) 675 printk(KERN_ERR "hda-codec: No codec parser is available\n"); 676 677 patched: 678 if (err < 0) { 679 snd_hda_codec_free(codec); 680 return err; 681 } 682 683 if (codec->patch_ops.unsol_event) 684 init_unsol_queue(bus); 685 686 snd_hda_codec_proc_new(codec); 687 #ifdef CONFIG_SND_HDA_HWDEP 688 snd_hda_create_hwdep(codec); 689 #endif 690 691 sprintf(component, "HDA:%08x", codec->vendor_id); 692 snd_component_add(codec->bus->card, component); 693 694 if (codecp) 695 *codecp = codec; 696 return 0; 697 } 698 699 /** 700 * snd_hda_codec_setup_stream - set up the codec for streaming 701 * @codec: the CODEC to set up 702 * @nid: the NID to set up 703 * @stream_tag: stream tag to pass, it's between 0x1 and 0xf. 704 * @channel_id: channel id to pass, zero based. 705 * @format: stream format. 706 */ 707 void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid, 708 u32 stream_tag, 709 int channel_id, int format) 710 { 711 if (!nid) 712 return; 713 714 snd_printdd("hda_codec_setup_stream: " 715 "NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n", 716 nid, stream_tag, channel_id, format); 717 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 718 (stream_tag << 4) | channel_id); 719 msleep(1); 720 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, format); 721 } 722 723 void snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid) 724 { 725 if (!nid) 726 return; 727 728 snd_printdd("hda_codec_cleanup_stream: NID=0x%x\n", nid); 729 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 0); 730 #if 0 /* keep the format */ 731 msleep(1); 732 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, 0); 733 #endif 734 } 735 736 /* 737 * amp access functions 738 */ 739 740 /* FIXME: more better hash key? */ 741 #define HDA_HASH_KEY(nid,dir,idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24)) 742 #define INFO_AMP_CAPS (1<<0) 743 #define INFO_AMP_VOL(ch) (1 << (1 + (ch))) 744 745 /* initialize the hash table */ 746 static void __devinit init_hda_cache(struct hda_cache_rec *cache, 747 unsigned int record_size) 748 { 749 memset(cache, 0, sizeof(*cache)); 750 memset(cache->hash, 0xff, sizeof(cache->hash)); 751 cache->record_size = record_size; 752 } 753 754 static void free_hda_cache(struct hda_cache_rec *cache) 755 { 756 kfree(cache->buffer); 757 } 758 759 /* query the hash. allocate an entry if not found. */ 760 static struct hda_cache_head *get_alloc_hash(struct hda_cache_rec *cache, 761 u32 key) 762 { 763 u16 idx = key % (u16)ARRAY_SIZE(cache->hash); 764 u16 cur = cache->hash[idx]; 765 struct hda_cache_head *info; 766 767 while (cur != 0xffff) { 768 info = (struct hda_cache_head *)(cache->buffer + 769 cur * cache->record_size); 770 if (info->key == key) 771 return info; 772 cur = info->next; 773 } 774 775 /* add a new hash entry */ 776 if (cache->num_entries >= cache->size) { 777 /* reallocate the array */ 778 unsigned int new_size = cache->size + 64; 779 void *new_buffer; 780 new_buffer = kcalloc(new_size, cache->record_size, GFP_KERNEL); 781 if (!new_buffer) { 782 snd_printk(KERN_ERR "hda_codec: " 783 "can't malloc amp_info\n"); 784 return NULL; 785 } 786 if (cache->buffer) { 787 memcpy(new_buffer, cache->buffer, 788 cache->size * cache->record_size); 789 kfree(cache->buffer); 790 } 791 cache->size = new_size; 792 cache->buffer = new_buffer; 793 } 794 cur = cache->num_entries++; 795 info = (struct hda_cache_head *)(cache->buffer + 796 cur * cache->record_size); 797 info->key = key; 798 info->val = 0; 799 info->next = cache->hash[idx]; 800 cache->hash[idx] = cur; 801 802 return info; 803 } 804 805 /* query and allocate an amp hash entry */ 806 static inline struct hda_amp_info * 807 get_alloc_amp_hash(struct hda_codec *codec, u32 key) 808 { 809 return (struct hda_amp_info *)get_alloc_hash(&codec->amp_cache, key); 810 } 811 812 /* 813 * query AMP capabilities for the given widget and direction 814 */ 815 u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction) 816 { 817 struct hda_amp_info *info; 818 819 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, 0)); 820 if (!info) 821 return 0; 822 if (!(info->head.val & INFO_AMP_CAPS)) { 823 if (!(get_wcaps(codec, nid) & AC_WCAP_AMP_OVRD)) 824 nid = codec->afg; 825 info->amp_caps = snd_hda_param_read(codec, nid, 826 direction == HDA_OUTPUT ? 827 AC_PAR_AMP_OUT_CAP : 828 AC_PAR_AMP_IN_CAP); 829 if (info->amp_caps) 830 info->head.val |= INFO_AMP_CAPS; 831 } 832 return info->amp_caps; 833 } 834 835 int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir, 836 unsigned int caps) 837 { 838 struct hda_amp_info *info; 839 840 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, dir, 0)); 841 if (!info) 842 return -EINVAL; 843 info->amp_caps = caps; 844 info->head.val |= INFO_AMP_CAPS; 845 return 0; 846 } 847 848 /* 849 * read the current volume to info 850 * if the cache exists, read the cache value. 851 */ 852 static unsigned int get_vol_mute(struct hda_codec *codec, 853 struct hda_amp_info *info, hda_nid_t nid, 854 int ch, int direction, int index) 855 { 856 u32 val, parm; 857 858 if (info->head.val & INFO_AMP_VOL(ch)) 859 return info->vol[ch]; 860 861 parm = ch ? AC_AMP_GET_RIGHT : AC_AMP_GET_LEFT; 862 parm |= direction == HDA_OUTPUT ? AC_AMP_GET_OUTPUT : AC_AMP_GET_INPUT; 863 parm |= index; 864 val = snd_hda_codec_read(codec, nid, 0, 865 AC_VERB_GET_AMP_GAIN_MUTE, parm); 866 info->vol[ch] = val & 0xff; 867 info->head.val |= INFO_AMP_VOL(ch); 868 return info->vol[ch]; 869 } 870 871 /* 872 * write the current volume in info to the h/w and update the cache 873 */ 874 static void put_vol_mute(struct hda_codec *codec, struct hda_amp_info *info, 875 hda_nid_t nid, int ch, int direction, int index, 876 int val) 877 { 878 u32 parm; 879 880 parm = ch ? AC_AMP_SET_RIGHT : AC_AMP_SET_LEFT; 881 parm |= direction == HDA_OUTPUT ? AC_AMP_SET_OUTPUT : AC_AMP_SET_INPUT; 882 parm |= index << AC_AMP_SET_INDEX_SHIFT; 883 parm |= val; 884 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, parm); 885 info->vol[ch] = val; 886 } 887 888 /* 889 * read AMP value. The volume is between 0 to 0x7f, 0x80 = mute bit. 890 */ 891 int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch, 892 int direction, int index) 893 { 894 struct hda_amp_info *info; 895 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, index)); 896 if (!info) 897 return 0; 898 return get_vol_mute(codec, info, nid, ch, direction, index); 899 } 900 901 /* 902 * update the AMP value, mask = bit mask to set, val = the value 903 */ 904 int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch, 905 int direction, int idx, int mask, int val) 906 { 907 struct hda_amp_info *info; 908 909 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, idx)); 910 if (!info) 911 return 0; 912 val &= mask; 913 val |= get_vol_mute(codec, info, nid, ch, direction, idx) & ~mask; 914 if (info->vol[ch] == val) 915 return 0; 916 put_vol_mute(codec, info, nid, ch, direction, idx, val); 917 return 1; 918 } 919 920 /* 921 * update the AMP stereo with the same mask and value 922 */ 923 int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid, 924 int direction, int idx, int mask, int val) 925 { 926 int ch, ret = 0; 927 for (ch = 0; ch < 2; ch++) 928 ret |= snd_hda_codec_amp_update(codec, nid, ch, direction, 929 idx, mask, val); 930 return ret; 931 } 932 933 #ifdef SND_HDA_NEEDS_RESUME 934 /* resume the all amp commands from the cache */ 935 void snd_hda_codec_resume_amp(struct hda_codec *codec) 936 { 937 struct hda_amp_info *buffer = codec->amp_cache.buffer; 938 int i; 939 940 for (i = 0; i < codec->amp_cache.size; i++, buffer++) { 941 u32 key = buffer->head.key; 942 hda_nid_t nid; 943 unsigned int idx, dir, ch; 944 if (!key) 945 continue; 946 nid = key & 0xff; 947 idx = (key >> 16) & 0xff; 948 dir = (key >> 24) & 0xff; 949 for (ch = 0; ch < 2; ch++) { 950 if (!(buffer->head.val & INFO_AMP_VOL(ch))) 951 continue; 952 put_vol_mute(codec, buffer, nid, ch, dir, idx, 953 buffer->vol[ch]); 954 } 955 } 956 } 957 #endif /* SND_HDA_NEEDS_RESUME */ 958 959 /* 960 * AMP control callbacks 961 */ 962 /* retrieve parameters from private_value */ 963 #define get_amp_nid(kc) ((kc)->private_value & 0xffff) 964 #define get_amp_channels(kc) (((kc)->private_value >> 16) & 0x3) 965 #define get_amp_direction(kc) (((kc)->private_value >> 18) & 0x1) 966 #define get_amp_index(kc) (((kc)->private_value >> 19) & 0xf) 967 968 /* volume */ 969 int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol, 970 struct snd_ctl_elem_info *uinfo) 971 { 972 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 973 u16 nid = get_amp_nid(kcontrol); 974 u8 chs = get_amp_channels(kcontrol); 975 int dir = get_amp_direction(kcontrol); 976 u32 caps; 977 978 caps = query_amp_caps(codec, nid, dir); 979 /* num steps */ 980 caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT; 981 if (!caps) { 982 printk(KERN_WARNING "hda_codec: " 983 "num_steps = 0 for NID=0x%x (ctl = %s)\n", nid, 984 kcontrol->id.name); 985 return -EINVAL; 986 } 987 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 988 uinfo->count = chs == 3 ? 2 : 1; 989 uinfo->value.integer.min = 0; 990 uinfo->value.integer.max = caps; 991 return 0; 992 } 993 994 int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol, 995 struct snd_ctl_elem_value *ucontrol) 996 { 997 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 998 hda_nid_t nid = get_amp_nid(kcontrol); 999 int chs = get_amp_channels(kcontrol); 1000 int dir = get_amp_direction(kcontrol); 1001 int idx = get_amp_index(kcontrol); 1002 long *valp = ucontrol->value.integer.value; 1003 1004 if (chs & 1) 1005 *valp++ = snd_hda_codec_amp_read(codec, nid, 0, dir, idx) 1006 & HDA_AMP_VOLMASK; 1007 if (chs & 2) 1008 *valp = snd_hda_codec_amp_read(codec, nid, 1, dir, idx) 1009 & HDA_AMP_VOLMASK; 1010 return 0; 1011 } 1012 1013 int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol, 1014 struct snd_ctl_elem_value *ucontrol) 1015 { 1016 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1017 hda_nid_t nid = get_amp_nid(kcontrol); 1018 int chs = get_amp_channels(kcontrol); 1019 int dir = get_amp_direction(kcontrol); 1020 int idx = get_amp_index(kcontrol); 1021 long *valp = ucontrol->value.integer.value; 1022 int change = 0; 1023 1024 snd_hda_power_up(codec); 1025 if (chs & 1) { 1026 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx, 1027 0x7f, *valp); 1028 valp++; 1029 } 1030 if (chs & 2) 1031 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx, 1032 0x7f, *valp); 1033 snd_hda_power_down(codec); 1034 return change; 1035 } 1036 1037 int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag, 1038 unsigned int size, unsigned int __user *_tlv) 1039 { 1040 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1041 hda_nid_t nid = get_amp_nid(kcontrol); 1042 int dir = get_amp_direction(kcontrol); 1043 u32 caps, val1, val2; 1044 1045 if (size < 4 * sizeof(unsigned int)) 1046 return -ENOMEM; 1047 caps = query_amp_caps(codec, nid, dir); 1048 val2 = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT; 1049 val2 = (val2 + 1) * 25; 1050 val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT); 1051 val1 = ((int)val1) * ((int)val2); 1052 if (put_user(SNDRV_CTL_TLVT_DB_SCALE, _tlv)) 1053 return -EFAULT; 1054 if (put_user(2 * sizeof(unsigned int), _tlv + 1)) 1055 return -EFAULT; 1056 if (put_user(val1, _tlv + 2)) 1057 return -EFAULT; 1058 if (put_user(val2, _tlv + 3)) 1059 return -EFAULT; 1060 return 0; 1061 } 1062 1063 /* 1064 * set (static) TLV for virtual master volume; recalculated as max 0dB 1065 */ 1066 void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir, 1067 unsigned int *tlv) 1068 { 1069 u32 caps; 1070 int nums, step; 1071 1072 caps = query_amp_caps(codec, nid, dir); 1073 nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT; 1074 step = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT; 1075 step = (step + 1) * 25; 1076 tlv[0] = SNDRV_CTL_TLVT_DB_SCALE; 1077 tlv[1] = 2 * sizeof(unsigned int); 1078 tlv[2] = -nums * step; 1079 tlv[3] = step; 1080 } 1081 1082 /* find a mixer control element with the given name */ 1083 static struct snd_kcontrol * 1084 _snd_hda_find_mixer_ctl(struct hda_codec *codec, 1085 const char *name, int idx) 1086 { 1087 struct snd_ctl_elem_id id; 1088 memset(&id, 0, sizeof(id)); 1089 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER; 1090 id.index = idx; 1091 strcpy(id.name, name); 1092 return snd_ctl_find_id(codec->bus->card, &id); 1093 } 1094 1095 struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec, 1096 const char *name) 1097 { 1098 return _snd_hda_find_mixer_ctl(codec, name, 0); 1099 } 1100 1101 /* create a virtual master control and add slaves */ 1102 int snd_hda_add_vmaster(struct hda_codec *codec, char *name, 1103 unsigned int *tlv, const char **slaves) 1104 { 1105 struct snd_kcontrol *kctl; 1106 const char **s; 1107 int err; 1108 1109 for (s = slaves; *s && !snd_hda_find_mixer_ctl(codec, *s); s++) 1110 ; 1111 if (!*s) { 1112 snd_printdd("No slave found for %s\n", name); 1113 return 0; 1114 } 1115 kctl = snd_ctl_make_virtual_master(name, tlv); 1116 if (!kctl) 1117 return -ENOMEM; 1118 err = snd_ctl_add(codec->bus->card, kctl); 1119 if (err < 0) 1120 return err; 1121 1122 for (s = slaves; *s; s++) { 1123 struct snd_kcontrol *sctl; 1124 1125 sctl = snd_hda_find_mixer_ctl(codec, *s); 1126 if (!sctl) { 1127 snd_printdd("Cannot find slave %s, skipped\n", *s); 1128 continue; 1129 } 1130 err = snd_ctl_add_slave(kctl, sctl); 1131 if (err < 0) 1132 return err; 1133 } 1134 return 0; 1135 } 1136 1137 /* switch */ 1138 int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol, 1139 struct snd_ctl_elem_info *uinfo) 1140 { 1141 int chs = get_amp_channels(kcontrol); 1142 1143 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; 1144 uinfo->count = chs == 3 ? 2 : 1; 1145 uinfo->value.integer.min = 0; 1146 uinfo->value.integer.max = 1; 1147 return 0; 1148 } 1149 1150 int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol, 1151 struct snd_ctl_elem_value *ucontrol) 1152 { 1153 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1154 hda_nid_t nid = get_amp_nid(kcontrol); 1155 int chs = get_amp_channels(kcontrol); 1156 int dir = get_amp_direction(kcontrol); 1157 int idx = get_amp_index(kcontrol); 1158 long *valp = ucontrol->value.integer.value; 1159 1160 if (chs & 1) 1161 *valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) & 1162 HDA_AMP_MUTE) ? 0 : 1; 1163 if (chs & 2) 1164 *valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) & 1165 HDA_AMP_MUTE) ? 0 : 1; 1166 return 0; 1167 } 1168 1169 int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol, 1170 struct snd_ctl_elem_value *ucontrol) 1171 { 1172 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1173 hda_nid_t nid = get_amp_nid(kcontrol); 1174 int chs = get_amp_channels(kcontrol); 1175 int dir = get_amp_direction(kcontrol); 1176 int idx = get_amp_index(kcontrol); 1177 long *valp = ucontrol->value.integer.value; 1178 int change = 0; 1179 1180 snd_hda_power_up(codec); 1181 if (chs & 1) { 1182 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx, 1183 HDA_AMP_MUTE, 1184 *valp ? 0 : HDA_AMP_MUTE); 1185 valp++; 1186 } 1187 if (chs & 2) 1188 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx, 1189 HDA_AMP_MUTE, 1190 *valp ? 0 : HDA_AMP_MUTE); 1191 #ifdef CONFIG_SND_HDA_POWER_SAVE 1192 if (codec->patch_ops.check_power_status) 1193 codec->patch_ops.check_power_status(codec, nid); 1194 #endif 1195 snd_hda_power_down(codec); 1196 return change; 1197 } 1198 1199 /* 1200 * bound volume controls 1201 * 1202 * bind multiple volumes (# indices, from 0) 1203 */ 1204 1205 #define AMP_VAL_IDX_SHIFT 19 1206 #define AMP_VAL_IDX_MASK (0x0f<<19) 1207 1208 int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol, 1209 struct snd_ctl_elem_value *ucontrol) 1210 { 1211 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1212 unsigned long pval; 1213 int err; 1214 1215 mutex_lock(&codec->spdif_mutex); /* reuse spdif_mutex */ 1216 pval = kcontrol->private_value; 1217 kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */ 1218 err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol); 1219 kcontrol->private_value = pval; 1220 mutex_unlock(&codec->spdif_mutex); 1221 return err; 1222 } 1223 1224 int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol, 1225 struct snd_ctl_elem_value *ucontrol) 1226 { 1227 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1228 unsigned long pval; 1229 int i, indices, err = 0, change = 0; 1230 1231 mutex_lock(&codec->spdif_mutex); /* reuse spdif_mutex */ 1232 pval = kcontrol->private_value; 1233 indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT; 1234 for (i = 0; i < indices; i++) { 1235 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) | 1236 (i << AMP_VAL_IDX_SHIFT); 1237 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol); 1238 if (err < 0) 1239 break; 1240 change |= err; 1241 } 1242 kcontrol->private_value = pval; 1243 mutex_unlock(&codec->spdif_mutex); 1244 return err < 0 ? err : change; 1245 } 1246 1247 /* 1248 * generic bound volume/swtich controls 1249 */ 1250 int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol, 1251 struct snd_ctl_elem_info *uinfo) 1252 { 1253 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1254 struct hda_bind_ctls *c; 1255 int err; 1256 1257 mutex_lock(&codec->spdif_mutex); /* reuse spdif_mutex */ 1258 c = (struct hda_bind_ctls *)kcontrol->private_value; 1259 kcontrol->private_value = *c->values; 1260 err = c->ops->info(kcontrol, uinfo); 1261 kcontrol->private_value = (long)c; 1262 mutex_unlock(&codec->spdif_mutex); 1263 return err; 1264 } 1265 1266 int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol, 1267 struct snd_ctl_elem_value *ucontrol) 1268 { 1269 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1270 struct hda_bind_ctls *c; 1271 int err; 1272 1273 mutex_lock(&codec->spdif_mutex); /* reuse spdif_mutex */ 1274 c = (struct hda_bind_ctls *)kcontrol->private_value; 1275 kcontrol->private_value = *c->values; 1276 err = c->ops->get(kcontrol, ucontrol); 1277 kcontrol->private_value = (long)c; 1278 mutex_unlock(&codec->spdif_mutex); 1279 return err; 1280 } 1281 1282 int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol, 1283 struct snd_ctl_elem_value *ucontrol) 1284 { 1285 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1286 struct hda_bind_ctls *c; 1287 unsigned long *vals; 1288 int err = 0, change = 0; 1289 1290 mutex_lock(&codec->spdif_mutex); /* reuse spdif_mutex */ 1291 c = (struct hda_bind_ctls *)kcontrol->private_value; 1292 for (vals = c->values; *vals; vals++) { 1293 kcontrol->private_value = *vals; 1294 err = c->ops->put(kcontrol, ucontrol); 1295 if (err < 0) 1296 break; 1297 change |= err; 1298 } 1299 kcontrol->private_value = (long)c; 1300 mutex_unlock(&codec->spdif_mutex); 1301 return err < 0 ? err : change; 1302 } 1303 1304 int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag, 1305 unsigned int size, unsigned int __user *tlv) 1306 { 1307 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1308 struct hda_bind_ctls *c; 1309 int err; 1310 1311 mutex_lock(&codec->spdif_mutex); /* reuse spdif_mutex */ 1312 c = (struct hda_bind_ctls *)kcontrol->private_value; 1313 kcontrol->private_value = *c->values; 1314 err = c->ops->tlv(kcontrol, op_flag, size, tlv); 1315 kcontrol->private_value = (long)c; 1316 mutex_unlock(&codec->spdif_mutex); 1317 return err; 1318 } 1319 1320 struct hda_ctl_ops snd_hda_bind_vol = { 1321 .info = snd_hda_mixer_amp_volume_info, 1322 .get = snd_hda_mixer_amp_volume_get, 1323 .put = snd_hda_mixer_amp_volume_put, 1324 .tlv = snd_hda_mixer_amp_tlv 1325 }; 1326 1327 struct hda_ctl_ops snd_hda_bind_sw = { 1328 .info = snd_hda_mixer_amp_switch_info, 1329 .get = snd_hda_mixer_amp_switch_get, 1330 .put = snd_hda_mixer_amp_switch_put, 1331 .tlv = snd_hda_mixer_amp_tlv 1332 }; 1333 1334 /* 1335 * SPDIF out controls 1336 */ 1337 1338 static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol, 1339 struct snd_ctl_elem_info *uinfo) 1340 { 1341 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; 1342 uinfo->count = 1; 1343 return 0; 1344 } 1345 1346 static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol, 1347 struct snd_ctl_elem_value *ucontrol) 1348 { 1349 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL | 1350 IEC958_AES0_NONAUDIO | 1351 IEC958_AES0_CON_EMPHASIS_5015 | 1352 IEC958_AES0_CON_NOT_COPYRIGHT; 1353 ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY | 1354 IEC958_AES1_CON_ORIGINAL; 1355 return 0; 1356 } 1357 1358 static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol, 1359 struct snd_ctl_elem_value *ucontrol) 1360 { 1361 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL | 1362 IEC958_AES0_NONAUDIO | 1363 IEC958_AES0_PRO_EMPHASIS_5015; 1364 return 0; 1365 } 1366 1367 static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol, 1368 struct snd_ctl_elem_value *ucontrol) 1369 { 1370 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1371 1372 ucontrol->value.iec958.status[0] = codec->spdif_status & 0xff; 1373 ucontrol->value.iec958.status[1] = (codec->spdif_status >> 8) & 0xff; 1374 ucontrol->value.iec958.status[2] = (codec->spdif_status >> 16) & 0xff; 1375 ucontrol->value.iec958.status[3] = (codec->spdif_status >> 24) & 0xff; 1376 1377 return 0; 1378 } 1379 1380 /* convert from SPDIF status bits to HDA SPDIF bits 1381 * bit 0 (DigEn) is always set zero (to be filled later) 1382 */ 1383 static unsigned short convert_from_spdif_status(unsigned int sbits) 1384 { 1385 unsigned short val = 0; 1386 1387 if (sbits & IEC958_AES0_PROFESSIONAL) 1388 val |= AC_DIG1_PROFESSIONAL; 1389 if (sbits & IEC958_AES0_NONAUDIO) 1390 val |= AC_DIG1_NONAUDIO; 1391 if (sbits & IEC958_AES0_PROFESSIONAL) { 1392 if ((sbits & IEC958_AES0_PRO_EMPHASIS) == 1393 IEC958_AES0_PRO_EMPHASIS_5015) 1394 val |= AC_DIG1_EMPHASIS; 1395 } else { 1396 if ((sbits & IEC958_AES0_CON_EMPHASIS) == 1397 IEC958_AES0_CON_EMPHASIS_5015) 1398 val |= AC_DIG1_EMPHASIS; 1399 if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT)) 1400 val |= AC_DIG1_COPYRIGHT; 1401 if (sbits & (IEC958_AES1_CON_ORIGINAL << 8)) 1402 val |= AC_DIG1_LEVEL; 1403 val |= sbits & (IEC958_AES1_CON_CATEGORY << 8); 1404 } 1405 return val; 1406 } 1407 1408 /* convert to SPDIF status bits from HDA SPDIF bits 1409 */ 1410 static unsigned int convert_to_spdif_status(unsigned short val) 1411 { 1412 unsigned int sbits = 0; 1413 1414 if (val & AC_DIG1_NONAUDIO) 1415 sbits |= IEC958_AES0_NONAUDIO; 1416 if (val & AC_DIG1_PROFESSIONAL) 1417 sbits |= IEC958_AES0_PROFESSIONAL; 1418 if (sbits & IEC958_AES0_PROFESSIONAL) { 1419 if (sbits & AC_DIG1_EMPHASIS) 1420 sbits |= IEC958_AES0_PRO_EMPHASIS_5015; 1421 } else { 1422 if (val & AC_DIG1_EMPHASIS) 1423 sbits |= IEC958_AES0_CON_EMPHASIS_5015; 1424 if (!(val & AC_DIG1_COPYRIGHT)) 1425 sbits |= IEC958_AES0_CON_NOT_COPYRIGHT; 1426 if (val & AC_DIG1_LEVEL) 1427 sbits |= (IEC958_AES1_CON_ORIGINAL << 8); 1428 sbits |= val & (0x7f << 8); 1429 } 1430 return sbits; 1431 } 1432 1433 static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol, 1434 struct snd_ctl_elem_value *ucontrol) 1435 { 1436 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1437 hda_nid_t nid = kcontrol->private_value; 1438 unsigned short val; 1439 int change; 1440 1441 mutex_lock(&codec->spdif_mutex); 1442 codec->spdif_status = ucontrol->value.iec958.status[0] | 1443 ((unsigned int)ucontrol->value.iec958.status[1] << 8) | 1444 ((unsigned int)ucontrol->value.iec958.status[2] << 16) | 1445 ((unsigned int)ucontrol->value.iec958.status[3] << 24); 1446 val = convert_from_spdif_status(codec->spdif_status); 1447 val |= codec->spdif_ctls & 1; 1448 change = codec->spdif_ctls != val; 1449 codec->spdif_ctls = val; 1450 1451 if (change) { 1452 snd_hda_codec_write_cache(codec, nid, 0, 1453 AC_VERB_SET_DIGI_CONVERT_1, 1454 val & 0xff); 1455 snd_hda_codec_write_cache(codec, nid, 0, 1456 AC_VERB_SET_DIGI_CONVERT_2, 1457 val >> 8); 1458 } 1459 1460 mutex_unlock(&codec->spdif_mutex); 1461 return change; 1462 } 1463 1464 #define snd_hda_spdif_out_switch_info snd_ctl_boolean_mono_info 1465 1466 static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol, 1467 struct snd_ctl_elem_value *ucontrol) 1468 { 1469 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1470 1471 ucontrol->value.integer.value[0] = codec->spdif_ctls & AC_DIG1_ENABLE; 1472 return 0; 1473 } 1474 1475 static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol, 1476 struct snd_ctl_elem_value *ucontrol) 1477 { 1478 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1479 hda_nid_t nid = kcontrol->private_value; 1480 unsigned short val; 1481 int change; 1482 1483 mutex_lock(&codec->spdif_mutex); 1484 val = codec->spdif_ctls & ~AC_DIG1_ENABLE; 1485 if (ucontrol->value.integer.value[0]) 1486 val |= AC_DIG1_ENABLE; 1487 change = codec->spdif_ctls != val; 1488 if (change) { 1489 codec->spdif_ctls = val; 1490 snd_hda_codec_write_cache(codec, nid, 0, 1491 AC_VERB_SET_DIGI_CONVERT_1, 1492 val & 0xff); 1493 /* unmute amp switch (if any) */ 1494 if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) && 1495 (val & AC_DIG1_ENABLE)) 1496 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0, 1497 HDA_AMP_MUTE, 0); 1498 } 1499 mutex_unlock(&codec->spdif_mutex); 1500 return change; 1501 } 1502 1503 static struct snd_kcontrol_new dig_mixes[] = { 1504 { 1505 .access = SNDRV_CTL_ELEM_ACCESS_READ, 1506 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1507 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,CON_MASK), 1508 .info = snd_hda_spdif_mask_info, 1509 .get = snd_hda_spdif_cmask_get, 1510 }, 1511 { 1512 .access = SNDRV_CTL_ELEM_ACCESS_READ, 1513 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1514 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,PRO_MASK), 1515 .info = snd_hda_spdif_mask_info, 1516 .get = snd_hda_spdif_pmask_get, 1517 }, 1518 { 1519 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1520 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT), 1521 .info = snd_hda_spdif_mask_info, 1522 .get = snd_hda_spdif_default_get, 1523 .put = snd_hda_spdif_default_put, 1524 }, 1525 { 1526 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1527 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,SWITCH), 1528 .info = snd_hda_spdif_out_switch_info, 1529 .get = snd_hda_spdif_out_switch_get, 1530 .put = snd_hda_spdif_out_switch_put, 1531 }, 1532 { } /* end */ 1533 }; 1534 1535 #define SPDIF_MAX_IDX 4 /* 4 instances should be enough to probe */ 1536 1537 /** 1538 * snd_hda_create_spdif_out_ctls - create Output SPDIF-related controls 1539 * @codec: the HDA codec 1540 * @nid: audio out widget NID 1541 * 1542 * Creates controls related with the SPDIF output. 1543 * Called from each patch supporting the SPDIF out. 1544 * 1545 * Returns 0 if successful, or a negative error code. 1546 */ 1547 int snd_hda_create_spdif_out_ctls(struct hda_codec *codec, hda_nid_t nid) 1548 { 1549 int err; 1550 struct snd_kcontrol *kctl; 1551 struct snd_kcontrol_new *dig_mix; 1552 int idx; 1553 1554 for (idx = 0; idx < SPDIF_MAX_IDX; idx++) { 1555 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Playback Switch", 1556 idx)) 1557 break; 1558 } 1559 if (idx >= SPDIF_MAX_IDX) { 1560 printk(KERN_ERR "hda_codec: too many IEC958 outputs\n"); 1561 return -EBUSY; 1562 } 1563 for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) { 1564 kctl = snd_ctl_new1(dig_mix, codec); 1565 kctl->id.index = idx; 1566 kctl->private_value = nid; 1567 err = snd_ctl_add(codec->bus->card, kctl); 1568 if (err < 0) 1569 return err; 1570 } 1571 codec->spdif_ctls = 1572 snd_hda_codec_read(codec, nid, 0, 1573 AC_VERB_GET_DIGI_CONVERT_1, 0); 1574 codec->spdif_status = convert_to_spdif_status(codec->spdif_ctls); 1575 return 0; 1576 } 1577 1578 /* 1579 * SPDIF sharing with analog output 1580 */ 1581 static int spdif_share_sw_get(struct snd_kcontrol *kcontrol, 1582 struct snd_ctl_elem_value *ucontrol) 1583 { 1584 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol); 1585 ucontrol->value.integer.value[0] = mout->share_spdif; 1586 return 0; 1587 } 1588 1589 static int spdif_share_sw_put(struct snd_kcontrol *kcontrol, 1590 struct snd_ctl_elem_value *ucontrol) 1591 { 1592 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol); 1593 mout->share_spdif = !!ucontrol->value.integer.value[0]; 1594 return 0; 1595 } 1596 1597 static struct snd_kcontrol_new spdif_share_sw = { 1598 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1599 .name = "IEC958 Default PCM Playback Switch", 1600 .info = snd_ctl_boolean_mono_info, 1601 .get = spdif_share_sw_get, 1602 .put = spdif_share_sw_put, 1603 }; 1604 1605 int snd_hda_create_spdif_share_sw(struct hda_codec *codec, 1606 struct hda_multi_out *mout) 1607 { 1608 if (!mout->dig_out_nid) 1609 return 0; 1610 /* ATTENTION: here mout is passed as private_data, instead of codec */ 1611 return snd_ctl_add(codec->bus->card, 1612 snd_ctl_new1(&spdif_share_sw, mout)); 1613 } 1614 1615 /* 1616 * SPDIF input 1617 */ 1618 1619 #define snd_hda_spdif_in_switch_info snd_hda_spdif_out_switch_info 1620 1621 static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol, 1622 struct snd_ctl_elem_value *ucontrol) 1623 { 1624 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1625 1626 ucontrol->value.integer.value[0] = codec->spdif_in_enable; 1627 return 0; 1628 } 1629 1630 static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol, 1631 struct snd_ctl_elem_value *ucontrol) 1632 { 1633 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1634 hda_nid_t nid = kcontrol->private_value; 1635 unsigned int val = !!ucontrol->value.integer.value[0]; 1636 int change; 1637 1638 mutex_lock(&codec->spdif_mutex); 1639 change = codec->spdif_in_enable != val; 1640 if (change) { 1641 codec->spdif_in_enable = val; 1642 snd_hda_codec_write_cache(codec, nid, 0, 1643 AC_VERB_SET_DIGI_CONVERT_1, val); 1644 } 1645 mutex_unlock(&codec->spdif_mutex); 1646 return change; 1647 } 1648 1649 static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol, 1650 struct snd_ctl_elem_value *ucontrol) 1651 { 1652 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1653 hda_nid_t nid = kcontrol->private_value; 1654 unsigned short val; 1655 unsigned int sbits; 1656 1657 val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DIGI_CONVERT_1, 0); 1658 sbits = convert_to_spdif_status(val); 1659 ucontrol->value.iec958.status[0] = sbits; 1660 ucontrol->value.iec958.status[1] = sbits >> 8; 1661 ucontrol->value.iec958.status[2] = sbits >> 16; 1662 ucontrol->value.iec958.status[3] = sbits >> 24; 1663 return 0; 1664 } 1665 1666 static struct snd_kcontrol_new dig_in_ctls[] = { 1667 { 1668 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1669 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,SWITCH), 1670 .info = snd_hda_spdif_in_switch_info, 1671 .get = snd_hda_spdif_in_switch_get, 1672 .put = snd_hda_spdif_in_switch_put, 1673 }, 1674 { 1675 .access = SNDRV_CTL_ELEM_ACCESS_READ, 1676 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1677 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,DEFAULT), 1678 .info = snd_hda_spdif_mask_info, 1679 .get = snd_hda_spdif_in_status_get, 1680 }, 1681 { } /* end */ 1682 }; 1683 1684 /** 1685 * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls 1686 * @codec: the HDA codec 1687 * @nid: audio in widget NID 1688 * 1689 * Creates controls related with the SPDIF input. 1690 * Called from each patch supporting the SPDIF in. 1691 * 1692 * Returns 0 if successful, or a negative error code. 1693 */ 1694 int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid) 1695 { 1696 int err; 1697 struct snd_kcontrol *kctl; 1698 struct snd_kcontrol_new *dig_mix; 1699 int idx; 1700 1701 for (idx = 0; idx < SPDIF_MAX_IDX; idx++) { 1702 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Capture Switch", 1703 idx)) 1704 break; 1705 } 1706 if (idx >= SPDIF_MAX_IDX) { 1707 printk(KERN_ERR "hda_codec: too many IEC958 inputs\n"); 1708 return -EBUSY; 1709 } 1710 for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) { 1711 kctl = snd_ctl_new1(dig_mix, codec); 1712 kctl->private_value = nid; 1713 err = snd_ctl_add(codec->bus->card, kctl); 1714 if (err < 0) 1715 return err; 1716 } 1717 codec->spdif_in_enable = 1718 snd_hda_codec_read(codec, nid, 0, 1719 AC_VERB_GET_DIGI_CONVERT_1, 0) & 1720 AC_DIG1_ENABLE; 1721 return 0; 1722 } 1723 1724 #ifdef SND_HDA_NEEDS_RESUME 1725 /* 1726 * command cache 1727 */ 1728 1729 /* build a 32bit cache key with the widget id and the command parameter */ 1730 #define build_cmd_cache_key(nid, verb) ((verb << 8) | nid) 1731 #define get_cmd_cache_nid(key) ((key) & 0xff) 1732 #define get_cmd_cache_cmd(key) (((key) >> 8) & 0xffff) 1733 1734 /** 1735 * snd_hda_codec_write_cache - send a single command with caching 1736 * @codec: the HDA codec 1737 * @nid: NID to send the command 1738 * @direct: direct flag 1739 * @verb: the verb to send 1740 * @parm: the parameter for the verb 1741 * 1742 * Send a single command without waiting for response. 1743 * 1744 * Returns 0 if successful, or a negative error code. 1745 */ 1746 int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid, 1747 int direct, unsigned int verb, unsigned int parm) 1748 { 1749 int err; 1750 snd_hda_power_up(codec); 1751 mutex_lock(&codec->bus->cmd_mutex); 1752 err = codec->bus->ops.command(codec, nid, direct, verb, parm); 1753 if (!err) { 1754 struct hda_cache_head *c; 1755 u32 key = build_cmd_cache_key(nid, verb); 1756 c = get_alloc_hash(&codec->cmd_cache, key); 1757 if (c) 1758 c->val = parm; 1759 } 1760 mutex_unlock(&codec->bus->cmd_mutex); 1761 snd_hda_power_down(codec); 1762 return err; 1763 } 1764 1765 /* resume the all commands from the cache */ 1766 void snd_hda_codec_resume_cache(struct hda_codec *codec) 1767 { 1768 struct hda_cache_head *buffer = codec->cmd_cache.buffer; 1769 int i; 1770 1771 for (i = 0; i < codec->cmd_cache.size; i++, buffer++) { 1772 u32 key = buffer->key; 1773 if (!key) 1774 continue; 1775 snd_hda_codec_write(codec, get_cmd_cache_nid(key), 0, 1776 get_cmd_cache_cmd(key), buffer->val); 1777 } 1778 } 1779 1780 /** 1781 * snd_hda_sequence_write_cache - sequence writes with caching 1782 * @codec: the HDA codec 1783 * @seq: VERB array to send 1784 * 1785 * Send the commands sequentially from the given array. 1786 * Thte commands are recorded on cache for power-save and resume. 1787 * The array must be terminated with NID=0. 1788 */ 1789 void snd_hda_sequence_write_cache(struct hda_codec *codec, 1790 const struct hda_verb *seq) 1791 { 1792 for (; seq->nid; seq++) 1793 snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb, 1794 seq->param); 1795 } 1796 #endif /* SND_HDA_NEEDS_RESUME */ 1797 1798 /* 1799 * set power state of the codec 1800 */ 1801 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg, 1802 unsigned int power_state) 1803 { 1804 hda_nid_t nid; 1805 int i; 1806 1807 snd_hda_codec_write(codec, fg, 0, AC_VERB_SET_POWER_STATE, 1808 power_state); 1809 msleep(10); /* partial workaround for "azx_get_response timeout" */ 1810 1811 nid = codec->start_nid; 1812 for (i = 0; i < codec->num_nodes; i++, nid++) { 1813 unsigned int wcaps = get_wcaps(codec, nid); 1814 if (wcaps & AC_WCAP_POWER) { 1815 unsigned int wid_type = (wcaps & AC_WCAP_TYPE) >> 1816 AC_WCAP_TYPE_SHIFT; 1817 if (wid_type == AC_WID_PIN) { 1818 unsigned int pincap; 1819 /* 1820 * don't power down the widget if it controls 1821 * eapd and EAPD_BTLENABLE is set. 1822 */ 1823 pincap = snd_hda_param_read(codec, nid, 1824 AC_PAR_PIN_CAP); 1825 if (pincap & AC_PINCAP_EAPD) { 1826 int eapd = snd_hda_codec_read(codec, 1827 nid, 0, 1828 AC_VERB_GET_EAPD_BTLENABLE, 0); 1829 eapd &= 0x02; 1830 if (power_state == AC_PWRST_D3 && eapd) 1831 continue; 1832 } 1833 } 1834 snd_hda_codec_write(codec, nid, 0, 1835 AC_VERB_SET_POWER_STATE, 1836 power_state); 1837 } 1838 } 1839 1840 if (power_state == AC_PWRST_D0) { 1841 unsigned long end_time; 1842 int state; 1843 msleep(10); 1844 /* wait until the codec reachs to D0 */ 1845 end_time = jiffies + msecs_to_jiffies(500); 1846 do { 1847 state = snd_hda_codec_read(codec, fg, 0, 1848 AC_VERB_GET_POWER_STATE, 0); 1849 if (state == power_state) 1850 break; 1851 msleep(1); 1852 } while (time_after_eq(end_time, jiffies)); 1853 } 1854 } 1855 1856 #ifdef SND_HDA_NEEDS_RESUME 1857 /* 1858 * call suspend and power-down; used both from PM and power-save 1859 */ 1860 static void hda_call_codec_suspend(struct hda_codec *codec) 1861 { 1862 if (codec->patch_ops.suspend) 1863 codec->patch_ops.suspend(codec, PMSG_SUSPEND); 1864 hda_set_power_state(codec, 1865 codec->afg ? codec->afg : codec->mfg, 1866 AC_PWRST_D3); 1867 #ifdef CONFIG_SND_HDA_POWER_SAVE 1868 cancel_delayed_work(&codec->power_work); 1869 codec->power_on = 0; 1870 codec->power_transition = 0; 1871 #endif 1872 } 1873 1874 /* 1875 * kick up codec; used both from PM and power-save 1876 */ 1877 static void hda_call_codec_resume(struct hda_codec *codec) 1878 { 1879 hda_set_power_state(codec, 1880 codec->afg ? codec->afg : codec->mfg, 1881 AC_PWRST_D0); 1882 if (codec->patch_ops.resume) 1883 codec->patch_ops.resume(codec); 1884 else { 1885 if (codec->patch_ops.init) 1886 codec->patch_ops.init(codec); 1887 snd_hda_codec_resume_amp(codec); 1888 snd_hda_codec_resume_cache(codec); 1889 } 1890 } 1891 #endif /* SND_HDA_NEEDS_RESUME */ 1892 1893 1894 /** 1895 * snd_hda_build_controls - build mixer controls 1896 * @bus: the BUS 1897 * 1898 * Creates mixer controls for each codec included in the bus. 1899 * 1900 * Returns 0 if successful, otherwise a negative error code. 1901 */ 1902 int __devinit snd_hda_build_controls(struct hda_bus *bus) 1903 { 1904 struct hda_codec *codec; 1905 1906 list_for_each_entry(codec, &bus->codec_list, list) { 1907 int err = 0; 1908 /* fake as if already powered-on */ 1909 hda_keep_power_on(codec); 1910 /* then fire up */ 1911 hda_set_power_state(codec, 1912 codec->afg ? codec->afg : codec->mfg, 1913 AC_PWRST_D0); 1914 /* continue to initialize... */ 1915 if (codec->patch_ops.init) 1916 err = codec->patch_ops.init(codec); 1917 if (!err && codec->patch_ops.build_controls) 1918 err = codec->patch_ops.build_controls(codec); 1919 snd_hda_power_down(codec); 1920 if (err < 0) 1921 return err; 1922 } 1923 1924 return 0; 1925 } 1926 1927 /* 1928 * stream formats 1929 */ 1930 struct hda_rate_tbl { 1931 unsigned int hz; 1932 unsigned int alsa_bits; 1933 unsigned int hda_fmt; 1934 }; 1935 1936 static struct hda_rate_tbl rate_bits[] = { 1937 /* rate in Hz, ALSA rate bitmask, HDA format value */ 1938 1939 /* autodetected value used in snd_hda_query_supported_pcm */ 1940 { 8000, SNDRV_PCM_RATE_8000, 0x0500 }, /* 1/6 x 48 */ 1941 { 11025, SNDRV_PCM_RATE_11025, 0x4300 }, /* 1/4 x 44 */ 1942 { 16000, SNDRV_PCM_RATE_16000, 0x0200 }, /* 1/3 x 48 */ 1943 { 22050, SNDRV_PCM_RATE_22050, 0x4100 }, /* 1/2 x 44 */ 1944 { 32000, SNDRV_PCM_RATE_32000, 0x0a00 }, /* 2/3 x 48 */ 1945 { 44100, SNDRV_PCM_RATE_44100, 0x4000 }, /* 44 */ 1946 { 48000, SNDRV_PCM_RATE_48000, 0x0000 }, /* 48 */ 1947 { 88200, SNDRV_PCM_RATE_88200, 0x4800 }, /* 2 x 44 */ 1948 { 96000, SNDRV_PCM_RATE_96000, 0x0800 }, /* 2 x 48 */ 1949 { 176400, SNDRV_PCM_RATE_176400, 0x5800 },/* 4 x 44 */ 1950 { 192000, SNDRV_PCM_RATE_192000, 0x1800 }, /* 4 x 48 */ 1951 #define AC_PAR_PCM_RATE_BITS 11 1952 /* up to bits 10, 384kHZ isn't supported properly */ 1953 1954 /* not autodetected value */ 1955 { 9600, SNDRV_PCM_RATE_KNOT, 0x0400 }, /* 1/5 x 48 */ 1956 1957 { 0 } /* terminator */ 1958 }; 1959 1960 /** 1961 * snd_hda_calc_stream_format - calculate format bitset 1962 * @rate: the sample rate 1963 * @channels: the number of channels 1964 * @format: the PCM format (SNDRV_PCM_FORMAT_XXX) 1965 * @maxbps: the max. bps 1966 * 1967 * Calculate the format bitset from the given rate, channels and th PCM format. 1968 * 1969 * Return zero if invalid. 1970 */ 1971 unsigned int snd_hda_calc_stream_format(unsigned int rate, 1972 unsigned int channels, 1973 unsigned int format, 1974 unsigned int maxbps) 1975 { 1976 int i; 1977 unsigned int val = 0; 1978 1979 for (i = 0; rate_bits[i].hz; i++) 1980 if (rate_bits[i].hz == rate) { 1981 val = rate_bits[i].hda_fmt; 1982 break; 1983 } 1984 if (!rate_bits[i].hz) { 1985 snd_printdd("invalid rate %d\n", rate); 1986 return 0; 1987 } 1988 1989 if (channels == 0 || channels > 8) { 1990 snd_printdd("invalid channels %d\n", channels); 1991 return 0; 1992 } 1993 val |= channels - 1; 1994 1995 switch (snd_pcm_format_width(format)) { 1996 case 8: val |= 0x00; break; 1997 case 16: val |= 0x10; break; 1998 case 20: 1999 case 24: 2000 case 32: 2001 if (maxbps >= 32) 2002 val |= 0x40; 2003 else if (maxbps >= 24) 2004 val |= 0x30; 2005 else 2006 val |= 0x20; 2007 break; 2008 default: 2009 snd_printdd("invalid format width %d\n", 2010 snd_pcm_format_width(format)); 2011 return 0; 2012 } 2013 2014 return val; 2015 } 2016 2017 /** 2018 * snd_hda_query_supported_pcm - query the supported PCM rates and formats 2019 * @codec: the HDA codec 2020 * @nid: NID to query 2021 * @ratesp: the pointer to store the detected rate bitflags 2022 * @formatsp: the pointer to store the detected formats 2023 * @bpsp: the pointer to store the detected format widths 2024 * 2025 * Queries the supported PCM rates and formats. The NULL @ratesp, @formatsp 2026 * or @bsps argument is ignored. 2027 * 2028 * Returns 0 if successful, otherwise a negative error code. 2029 */ 2030 int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid, 2031 u32 *ratesp, u64 *formatsp, unsigned int *bpsp) 2032 { 2033 int i; 2034 unsigned int val, streams; 2035 2036 val = 0; 2037 if (nid != codec->afg && 2038 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD)) { 2039 val = snd_hda_param_read(codec, nid, AC_PAR_PCM); 2040 if (val == -1) 2041 return -EIO; 2042 } 2043 if (!val) 2044 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM); 2045 2046 if (ratesp) { 2047 u32 rates = 0; 2048 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) { 2049 if (val & (1 << i)) 2050 rates |= rate_bits[i].alsa_bits; 2051 } 2052 *ratesp = rates; 2053 } 2054 2055 if (formatsp || bpsp) { 2056 u64 formats = 0; 2057 unsigned int bps; 2058 unsigned int wcaps; 2059 2060 wcaps = get_wcaps(codec, nid); 2061 streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM); 2062 if (streams == -1) 2063 return -EIO; 2064 if (!streams) { 2065 streams = snd_hda_param_read(codec, codec->afg, 2066 AC_PAR_STREAM); 2067 if (streams == -1) 2068 return -EIO; 2069 } 2070 2071 bps = 0; 2072 if (streams & AC_SUPFMT_PCM) { 2073 if (val & AC_SUPPCM_BITS_8) { 2074 formats |= SNDRV_PCM_FMTBIT_U8; 2075 bps = 8; 2076 } 2077 if (val & AC_SUPPCM_BITS_16) { 2078 formats |= SNDRV_PCM_FMTBIT_S16_LE; 2079 bps = 16; 2080 } 2081 if (wcaps & AC_WCAP_DIGITAL) { 2082 if (val & AC_SUPPCM_BITS_32) 2083 formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE; 2084 if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24)) 2085 formats |= SNDRV_PCM_FMTBIT_S32_LE; 2086 if (val & AC_SUPPCM_BITS_24) 2087 bps = 24; 2088 else if (val & AC_SUPPCM_BITS_20) 2089 bps = 20; 2090 } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24| 2091 AC_SUPPCM_BITS_32)) { 2092 formats |= SNDRV_PCM_FMTBIT_S32_LE; 2093 if (val & AC_SUPPCM_BITS_32) 2094 bps = 32; 2095 else if (val & AC_SUPPCM_BITS_24) 2096 bps = 24; 2097 else if (val & AC_SUPPCM_BITS_20) 2098 bps = 20; 2099 } 2100 } 2101 else if (streams == AC_SUPFMT_FLOAT32) { 2102 /* should be exclusive */ 2103 formats |= SNDRV_PCM_FMTBIT_FLOAT_LE; 2104 bps = 32; 2105 } else if (streams == AC_SUPFMT_AC3) { 2106 /* should be exclusive */ 2107 /* temporary hack: we have still no proper support 2108 * for the direct AC3 stream... 2109 */ 2110 formats |= SNDRV_PCM_FMTBIT_U8; 2111 bps = 8; 2112 } 2113 if (formatsp) 2114 *formatsp = formats; 2115 if (bpsp) 2116 *bpsp = bps; 2117 } 2118 2119 return 0; 2120 } 2121 2122 /** 2123 * snd_hda_is_supported_format - check whether the given node supports 2124 * the format val 2125 * 2126 * Returns 1 if supported, 0 if not. 2127 */ 2128 int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid, 2129 unsigned int format) 2130 { 2131 int i; 2132 unsigned int val = 0, rate, stream; 2133 2134 if (nid != codec->afg && 2135 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD)) { 2136 val = snd_hda_param_read(codec, nid, AC_PAR_PCM); 2137 if (val == -1) 2138 return 0; 2139 } 2140 if (!val) { 2141 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM); 2142 if (val == -1) 2143 return 0; 2144 } 2145 2146 rate = format & 0xff00; 2147 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) 2148 if (rate_bits[i].hda_fmt == rate) { 2149 if (val & (1 << i)) 2150 break; 2151 return 0; 2152 } 2153 if (i >= AC_PAR_PCM_RATE_BITS) 2154 return 0; 2155 2156 stream = snd_hda_param_read(codec, nid, AC_PAR_STREAM); 2157 if (stream == -1) 2158 return 0; 2159 if (!stream && nid != codec->afg) 2160 stream = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM); 2161 if (!stream || stream == -1) 2162 return 0; 2163 2164 if (stream & AC_SUPFMT_PCM) { 2165 switch (format & 0xf0) { 2166 case 0x00: 2167 if (!(val & AC_SUPPCM_BITS_8)) 2168 return 0; 2169 break; 2170 case 0x10: 2171 if (!(val & AC_SUPPCM_BITS_16)) 2172 return 0; 2173 break; 2174 case 0x20: 2175 if (!(val & AC_SUPPCM_BITS_20)) 2176 return 0; 2177 break; 2178 case 0x30: 2179 if (!(val & AC_SUPPCM_BITS_24)) 2180 return 0; 2181 break; 2182 case 0x40: 2183 if (!(val & AC_SUPPCM_BITS_32)) 2184 return 0; 2185 break; 2186 default: 2187 return 0; 2188 } 2189 } else { 2190 /* FIXME: check for float32 and AC3? */ 2191 } 2192 2193 return 1; 2194 } 2195 2196 /* 2197 * PCM stuff 2198 */ 2199 static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo, 2200 struct hda_codec *codec, 2201 struct snd_pcm_substream *substream) 2202 { 2203 return 0; 2204 } 2205 2206 static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo, 2207 struct hda_codec *codec, 2208 unsigned int stream_tag, 2209 unsigned int format, 2210 struct snd_pcm_substream *substream) 2211 { 2212 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format); 2213 return 0; 2214 } 2215 2216 static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo, 2217 struct hda_codec *codec, 2218 struct snd_pcm_substream *substream) 2219 { 2220 snd_hda_codec_cleanup_stream(codec, hinfo->nid); 2221 return 0; 2222 } 2223 2224 static int __devinit set_pcm_default_values(struct hda_codec *codec, 2225 struct hda_pcm_stream *info) 2226 { 2227 /* query support PCM information from the given NID */ 2228 if (info->nid && (!info->rates || !info->formats)) { 2229 snd_hda_query_supported_pcm(codec, info->nid, 2230 info->rates ? NULL : &info->rates, 2231 info->formats ? NULL : &info->formats, 2232 info->maxbps ? NULL : &info->maxbps); 2233 } 2234 if (info->ops.open == NULL) 2235 info->ops.open = hda_pcm_default_open_close; 2236 if (info->ops.close == NULL) 2237 info->ops.close = hda_pcm_default_open_close; 2238 if (info->ops.prepare == NULL) { 2239 snd_assert(info->nid, return -EINVAL); 2240 info->ops.prepare = hda_pcm_default_prepare; 2241 } 2242 if (info->ops.cleanup == NULL) { 2243 snd_assert(info->nid, return -EINVAL); 2244 info->ops.cleanup = hda_pcm_default_cleanup; 2245 } 2246 return 0; 2247 } 2248 2249 /** 2250 * snd_hda_build_pcms - build PCM information 2251 * @bus: the BUS 2252 * 2253 * Create PCM information for each codec included in the bus. 2254 * 2255 * The build_pcms codec patch is requested to set up codec->num_pcms and 2256 * codec->pcm_info properly. The array is referred by the top-level driver 2257 * to create its PCM instances. 2258 * The allocated codec->pcm_info should be released in codec->patch_ops.free 2259 * callback. 2260 * 2261 * At least, substreams, channels_min and channels_max must be filled for 2262 * each stream. substreams = 0 indicates that the stream doesn't exist. 2263 * When rates and/or formats are zero, the supported values are queried 2264 * from the given nid. The nid is used also by the default ops.prepare 2265 * and ops.cleanup callbacks. 2266 * 2267 * The driver needs to call ops.open in its open callback. Similarly, 2268 * ops.close is supposed to be called in the close callback. 2269 * ops.prepare should be called in the prepare or hw_params callback 2270 * with the proper parameters for set up. 2271 * ops.cleanup should be called in hw_free for clean up of streams. 2272 * 2273 * This function returns 0 if successfull, or a negative error code. 2274 */ 2275 int __devinit snd_hda_build_pcms(struct hda_bus *bus) 2276 { 2277 struct hda_codec *codec; 2278 2279 list_for_each_entry(codec, &bus->codec_list, list) { 2280 unsigned int pcm, s; 2281 int err; 2282 if (!codec->patch_ops.build_pcms) 2283 continue; 2284 err = codec->patch_ops.build_pcms(codec); 2285 if (err < 0) 2286 return err; 2287 for (pcm = 0; pcm < codec->num_pcms; pcm++) { 2288 for (s = 0; s < 2; s++) { 2289 struct hda_pcm_stream *info; 2290 info = &codec->pcm_info[pcm].stream[s]; 2291 if (!info->substreams) 2292 continue; 2293 err = set_pcm_default_values(codec, info); 2294 if (err < 0) 2295 return err; 2296 } 2297 } 2298 } 2299 return 0; 2300 } 2301 2302 /** 2303 * snd_hda_check_board_config - compare the current codec with the config table 2304 * @codec: the HDA codec 2305 * @num_configs: number of config enums 2306 * @models: array of model name strings 2307 * @tbl: configuration table, terminated by null entries 2308 * 2309 * Compares the modelname or PCI subsystem id of the current codec with the 2310 * given configuration table. If a matching entry is found, returns its 2311 * config value (supposed to be 0 or positive). 2312 * 2313 * If no entries are matching, the function returns a negative value. 2314 */ 2315 int snd_hda_check_board_config(struct hda_codec *codec, 2316 int num_configs, const char **models, 2317 const struct snd_pci_quirk *tbl) 2318 { 2319 if (codec->bus->modelname && models) { 2320 int i; 2321 for (i = 0; i < num_configs; i++) { 2322 if (models[i] && 2323 !strcmp(codec->bus->modelname, models[i])) { 2324 snd_printd(KERN_INFO "hda_codec: model '%s' is " 2325 "selected\n", models[i]); 2326 return i; 2327 } 2328 } 2329 } 2330 2331 if (!codec->bus->pci || !tbl) 2332 return -1; 2333 2334 tbl = snd_pci_quirk_lookup(codec->bus->pci, tbl); 2335 if (!tbl) 2336 return -1; 2337 if (tbl->value >= 0 && tbl->value < num_configs) { 2338 #ifdef CONFIG_SND_DEBUG_VERBOSE 2339 char tmp[10]; 2340 const char *model = NULL; 2341 if (models) 2342 model = models[tbl->value]; 2343 if (!model) { 2344 sprintf(tmp, "#%d", tbl->value); 2345 model = tmp; 2346 } 2347 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected " 2348 "for config %x:%x (%s)\n", 2349 model, tbl->subvendor, tbl->subdevice, 2350 (tbl->name ? tbl->name : "Unknown device")); 2351 #endif 2352 return tbl->value; 2353 } 2354 return -1; 2355 } 2356 2357 /** 2358 * snd_hda_add_new_ctls - create controls from the array 2359 * @codec: the HDA codec 2360 * @knew: the array of struct snd_kcontrol_new 2361 * 2362 * This helper function creates and add new controls in the given array. 2363 * The array must be terminated with an empty entry as terminator. 2364 * 2365 * Returns 0 if successful, or a negative error code. 2366 */ 2367 int snd_hda_add_new_ctls(struct hda_codec *codec, struct snd_kcontrol_new *knew) 2368 { 2369 int err; 2370 2371 for (; knew->name; knew++) { 2372 struct snd_kcontrol *kctl; 2373 kctl = snd_ctl_new1(knew, codec); 2374 if (!kctl) 2375 return -ENOMEM; 2376 err = snd_ctl_add(codec->bus->card, kctl); 2377 if (err < 0) { 2378 if (!codec->addr) 2379 return err; 2380 kctl = snd_ctl_new1(knew, codec); 2381 if (!kctl) 2382 return -ENOMEM; 2383 kctl->id.device = codec->addr; 2384 err = snd_ctl_add(codec->bus->card, kctl); 2385 if (err < 0) 2386 return err; 2387 } 2388 } 2389 return 0; 2390 } 2391 2392 #ifdef CONFIG_SND_HDA_POWER_SAVE 2393 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg, 2394 unsigned int power_state); 2395 2396 static void hda_power_work(struct work_struct *work) 2397 { 2398 struct hda_codec *codec = 2399 container_of(work, struct hda_codec, power_work.work); 2400 2401 if (!codec->power_on || codec->power_count) { 2402 codec->power_transition = 0; 2403 return; 2404 } 2405 2406 hda_call_codec_suspend(codec); 2407 if (codec->bus->ops.pm_notify) 2408 codec->bus->ops.pm_notify(codec); 2409 } 2410 2411 static void hda_keep_power_on(struct hda_codec *codec) 2412 { 2413 codec->power_count++; 2414 codec->power_on = 1; 2415 } 2416 2417 void snd_hda_power_up(struct hda_codec *codec) 2418 { 2419 codec->power_count++; 2420 if (codec->power_on || codec->power_transition) 2421 return; 2422 2423 codec->power_on = 1; 2424 if (codec->bus->ops.pm_notify) 2425 codec->bus->ops.pm_notify(codec); 2426 hda_call_codec_resume(codec); 2427 cancel_delayed_work(&codec->power_work); 2428 codec->power_transition = 0; 2429 } 2430 2431 void snd_hda_power_down(struct hda_codec *codec) 2432 { 2433 --codec->power_count; 2434 if (!codec->power_on || codec->power_count || codec->power_transition) 2435 return; 2436 if (power_save) { 2437 codec->power_transition = 1; /* avoid reentrance */ 2438 schedule_delayed_work(&codec->power_work, 2439 msecs_to_jiffies(power_save * 1000)); 2440 } 2441 } 2442 2443 int snd_hda_check_amp_list_power(struct hda_codec *codec, 2444 struct hda_loopback_check *check, 2445 hda_nid_t nid) 2446 { 2447 struct hda_amp_list *p; 2448 int ch, v; 2449 2450 if (!check->amplist) 2451 return 0; 2452 for (p = check->amplist; p->nid; p++) { 2453 if (p->nid == nid) 2454 break; 2455 } 2456 if (!p->nid) 2457 return 0; /* nothing changed */ 2458 2459 for (p = check->amplist; p->nid; p++) { 2460 for (ch = 0; ch < 2; ch++) { 2461 v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir, 2462 p->idx); 2463 if (!(v & HDA_AMP_MUTE) && v > 0) { 2464 if (!check->power_on) { 2465 check->power_on = 1; 2466 snd_hda_power_up(codec); 2467 } 2468 return 1; 2469 } 2470 } 2471 } 2472 if (check->power_on) { 2473 check->power_on = 0; 2474 snd_hda_power_down(codec); 2475 } 2476 return 0; 2477 } 2478 #endif 2479 2480 /* 2481 * Channel mode helper 2482 */ 2483 int snd_hda_ch_mode_info(struct hda_codec *codec, 2484 struct snd_ctl_elem_info *uinfo, 2485 const struct hda_channel_mode *chmode, 2486 int num_chmodes) 2487 { 2488 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 2489 uinfo->count = 1; 2490 uinfo->value.enumerated.items = num_chmodes; 2491 if (uinfo->value.enumerated.item >= num_chmodes) 2492 uinfo->value.enumerated.item = num_chmodes - 1; 2493 sprintf(uinfo->value.enumerated.name, "%dch", 2494 chmode[uinfo->value.enumerated.item].channels); 2495 return 0; 2496 } 2497 2498 int snd_hda_ch_mode_get(struct hda_codec *codec, 2499 struct snd_ctl_elem_value *ucontrol, 2500 const struct hda_channel_mode *chmode, 2501 int num_chmodes, 2502 int max_channels) 2503 { 2504 int i; 2505 2506 for (i = 0; i < num_chmodes; i++) { 2507 if (max_channels == chmode[i].channels) { 2508 ucontrol->value.enumerated.item[0] = i; 2509 break; 2510 } 2511 } 2512 return 0; 2513 } 2514 2515 int snd_hda_ch_mode_put(struct hda_codec *codec, 2516 struct snd_ctl_elem_value *ucontrol, 2517 const struct hda_channel_mode *chmode, 2518 int num_chmodes, 2519 int *max_channelsp) 2520 { 2521 unsigned int mode; 2522 2523 mode = ucontrol->value.enumerated.item[0]; 2524 if (mode >= num_chmodes) 2525 return -EINVAL; 2526 if (*max_channelsp == chmode[mode].channels) 2527 return 0; 2528 /* change the current channel setting */ 2529 *max_channelsp = chmode[mode].channels; 2530 if (chmode[mode].sequence) 2531 snd_hda_sequence_write_cache(codec, chmode[mode].sequence); 2532 return 1; 2533 } 2534 2535 /* 2536 * input MUX helper 2537 */ 2538 int snd_hda_input_mux_info(const struct hda_input_mux *imux, 2539 struct snd_ctl_elem_info *uinfo) 2540 { 2541 unsigned int index; 2542 2543 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 2544 uinfo->count = 1; 2545 uinfo->value.enumerated.items = imux->num_items; 2546 if (!imux->num_items) 2547 return 0; 2548 index = uinfo->value.enumerated.item; 2549 if (index >= imux->num_items) 2550 index = imux->num_items - 1; 2551 strcpy(uinfo->value.enumerated.name, imux->items[index].label); 2552 return 0; 2553 } 2554 2555 int snd_hda_input_mux_put(struct hda_codec *codec, 2556 const struct hda_input_mux *imux, 2557 struct snd_ctl_elem_value *ucontrol, 2558 hda_nid_t nid, 2559 unsigned int *cur_val) 2560 { 2561 unsigned int idx; 2562 2563 if (!imux->num_items) 2564 return 0; 2565 idx = ucontrol->value.enumerated.item[0]; 2566 if (idx >= imux->num_items) 2567 idx = imux->num_items - 1; 2568 if (*cur_val == idx) 2569 return 0; 2570 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, 2571 imux->items[idx].index); 2572 *cur_val = idx; 2573 return 1; 2574 } 2575 2576 2577 /* 2578 * Multi-channel / digital-out PCM helper functions 2579 */ 2580 2581 /* setup SPDIF output stream */ 2582 static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid, 2583 unsigned int stream_tag, unsigned int format) 2584 { 2585 /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */ 2586 if (codec->spdif_ctls & AC_DIG1_ENABLE) 2587 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1, 2588 codec->spdif_ctls & ~AC_DIG1_ENABLE & 0xff); 2589 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format); 2590 /* turn on again (if needed) */ 2591 if (codec->spdif_ctls & AC_DIG1_ENABLE) 2592 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1, 2593 codec->spdif_ctls & 0xff); 2594 } 2595 2596 /* 2597 * open the digital out in the exclusive mode 2598 */ 2599 int snd_hda_multi_out_dig_open(struct hda_codec *codec, 2600 struct hda_multi_out *mout) 2601 { 2602 mutex_lock(&codec->spdif_mutex); 2603 if (mout->dig_out_used == HDA_DIG_ANALOG_DUP) 2604 /* already opened as analog dup; reset it once */ 2605 snd_hda_codec_cleanup_stream(codec, mout->dig_out_nid); 2606 mout->dig_out_used = HDA_DIG_EXCLUSIVE; 2607 mutex_unlock(&codec->spdif_mutex); 2608 return 0; 2609 } 2610 2611 int snd_hda_multi_out_dig_prepare(struct hda_codec *codec, 2612 struct hda_multi_out *mout, 2613 unsigned int stream_tag, 2614 unsigned int format, 2615 struct snd_pcm_substream *substream) 2616 { 2617 mutex_lock(&codec->spdif_mutex); 2618 setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format); 2619 mutex_unlock(&codec->spdif_mutex); 2620 return 0; 2621 } 2622 2623 /* 2624 * release the digital out 2625 */ 2626 int snd_hda_multi_out_dig_close(struct hda_codec *codec, 2627 struct hda_multi_out *mout) 2628 { 2629 mutex_lock(&codec->spdif_mutex); 2630 mout->dig_out_used = 0; 2631 mutex_unlock(&codec->spdif_mutex); 2632 return 0; 2633 } 2634 2635 /* 2636 * set up more restrictions for analog out 2637 */ 2638 int snd_hda_multi_out_analog_open(struct hda_codec *codec, 2639 struct hda_multi_out *mout, 2640 struct snd_pcm_substream *substream, 2641 struct hda_pcm_stream *hinfo) 2642 { 2643 struct snd_pcm_runtime *runtime = substream->runtime; 2644 runtime->hw.channels_max = mout->max_channels; 2645 if (mout->dig_out_nid) { 2646 if (!mout->analog_rates) { 2647 mout->analog_rates = hinfo->rates; 2648 mout->analog_formats = hinfo->formats; 2649 mout->analog_maxbps = hinfo->maxbps; 2650 } else { 2651 runtime->hw.rates = mout->analog_rates; 2652 runtime->hw.formats = mout->analog_formats; 2653 hinfo->maxbps = mout->analog_maxbps; 2654 } 2655 if (!mout->spdif_rates) { 2656 snd_hda_query_supported_pcm(codec, mout->dig_out_nid, 2657 &mout->spdif_rates, 2658 &mout->spdif_formats, 2659 &mout->spdif_maxbps); 2660 } 2661 mutex_lock(&codec->spdif_mutex); 2662 if (mout->share_spdif) { 2663 runtime->hw.rates &= mout->spdif_rates; 2664 runtime->hw.formats &= mout->spdif_formats; 2665 if (mout->spdif_maxbps < hinfo->maxbps) 2666 hinfo->maxbps = mout->spdif_maxbps; 2667 } 2668 mutex_unlock(&codec->spdif_mutex); 2669 } 2670 return snd_pcm_hw_constraint_step(substream->runtime, 0, 2671 SNDRV_PCM_HW_PARAM_CHANNELS, 2); 2672 } 2673 2674 /* 2675 * set up the i/o for analog out 2676 * when the digital out is available, copy the front out to digital out, too. 2677 */ 2678 int snd_hda_multi_out_analog_prepare(struct hda_codec *codec, 2679 struct hda_multi_out *mout, 2680 unsigned int stream_tag, 2681 unsigned int format, 2682 struct snd_pcm_substream *substream) 2683 { 2684 hda_nid_t *nids = mout->dac_nids; 2685 int chs = substream->runtime->channels; 2686 int i; 2687 2688 mutex_lock(&codec->spdif_mutex); 2689 if (mout->dig_out_nid && mout->share_spdif && 2690 mout->dig_out_used != HDA_DIG_EXCLUSIVE) { 2691 if (chs == 2 && 2692 snd_hda_is_supported_format(codec, mout->dig_out_nid, 2693 format) && 2694 !(codec->spdif_status & IEC958_AES0_NONAUDIO)) { 2695 mout->dig_out_used = HDA_DIG_ANALOG_DUP; 2696 setup_dig_out_stream(codec, mout->dig_out_nid, 2697 stream_tag, format); 2698 } else { 2699 mout->dig_out_used = 0; 2700 snd_hda_codec_cleanup_stream(codec, mout->dig_out_nid); 2701 } 2702 } 2703 mutex_unlock(&codec->spdif_mutex); 2704 2705 /* front */ 2706 snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag, 2707 0, format); 2708 if (!mout->no_share_stream && 2709 mout->hp_nid && mout->hp_nid != nids[HDA_FRONT]) 2710 /* headphone out will just decode front left/right (stereo) */ 2711 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag, 2712 0, format); 2713 /* extra outputs copied from front */ 2714 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++) 2715 if (!mout->no_share_stream && mout->extra_out_nid[i]) 2716 snd_hda_codec_setup_stream(codec, 2717 mout->extra_out_nid[i], 2718 stream_tag, 0, format); 2719 2720 /* surrounds */ 2721 for (i = 1; i < mout->num_dacs; i++) { 2722 if (chs >= (i + 1) * 2) /* independent out */ 2723 snd_hda_codec_setup_stream(codec, nids[i], stream_tag, 2724 i * 2, format); 2725 else if (!mout->no_share_stream) /* copy front */ 2726 snd_hda_codec_setup_stream(codec, nids[i], stream_tag, 2727 0, format); 2728 } 2729 return 0; 2730 } 2731 2732 /* 2733 * clean up the setting for analog out 2734 */ 2735 int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec, 2736 struct hda_multi_out *mout) 2737 { 2738 hda_nid_t *nids = mout->dac_nids; 2739 int i; 2740 2741 for (i = 0; i < mout->num_dacs; i++) 2742 snd_hda_codec_cleanup_stream(codec, nids[i]); 2743 if (mout->hp_nid) 2744 snd_hda_codec_cleanup_stream(codec, mout->hp_nid); 2745 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++) 2746 if (mout->extra_out_nid[i]) 2747 snd_hda_codec_cleanup_stream(codec, 2748 mout->extra_out_nid[i]); 2749 mutex_lock(&codec->spdif_mutex); 2750 if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) { 2751 snd_hda_codec_cleanup_stream(codec, mout->dig_out_nid); 2752 mout->dig_out_used = 0; 2753 } 2754 mutex_unlock(&codec->spdif_mutex); 2755 return 0; 2756 } 2757 2758 /* 2759 * Helper for automatic ping configuration 2760 */ 2761 2762 static int is_in_nid_list(hda_nid_t nid, hda_nid_t *list) 2763 { 2764 for (; *list; list++) 2765 if (*list == nid) 2766 return 1; 2767 return 0; 2768 } 2769 2770 2771 /* 2772 * Sort an associated group of pins according to their sequence numbers. 2773 */ 2774 static void sort_pins_by_sequence(hda_nid_t * pins, short * sequences, 2775 int num_pins) 2776 { 2777 int i, j; 2778 short seq; 2779 hda_nid_t nid; 2780 2781 for (i = 0; i < num_pins; i++) { 2782 for (j = i + 1; j < num_pins; j++) { 2783 if (sequences[i] > sequences[j]) { 2784 seq = sequences[i]; 2785 sequences[i] = sequences[j]; 2786 sequences[j] = seq; 2787 nid = pins[i]; 2788 pins[i] = pins[j]; 2789 pins[j] = nid; 2790 } 2791 } 2792 } 2793 } 2794 2795 2796 /* 2797 * Parse all pin widgets and store the useful pin nids to cfg 2798 * 2799 * The number of line-outs or any primary output is stored in line_outs, 2800 * and the corresponding output pins are assigned to line_out_pins[], 2801 * in the order of front, rear, CLFE, side, ... 2802 * 2803 * If more extra outputs (speaker and headphone) are found, the pins are 2804 * assisnged to hp_pins[] and speaker_pins[], respectively. If no line-out jack 2805 * is detected, one of speaker of HP pins is assigned as the primary 2806 * output, i.e. to line_out_pins[0]. So, line_outs is always positive 2807 * if any analog output exists. 2808 * 2809 * The analog input pins are assigned to input_pins array. 2810 * The digital input/output pins are assigned to dig_in_pin and dig_out_pin, 2811 * respectively. 2812 */ 2813 int snd_hda_parse_pin_def_config(struct hda_codec *codec, 2814 struct auto_pin_cfg *cfg, 2815 hda_nid_t *ignore_nids) 2816 { 2817 hda_nid_t nid, end_nid; 2818 short seq, assoc_line_out, assoc_speaker; 2819 short sequences_line_out[ARRAY_SIZE(cfg->line_out_pins)]; 2820 short sequences_speaker[ARRAY_SIZE(cfg->speaker_pins)]; 2821 short sequences_hp[ARRAY_SIZE(cfg->hp_pins)]; 2822 2823 memset(cfg, 0, sizeof(*cfg)); 2824 2825 memset(sequences_line_out, 0, sizeof(sequences_line_out)); 2826 memset(sequences_speaker, 0, sizeof(sequences_speaker)); 2827 memset(sequences_hp, 0, sizeof(sequences_hp)); 2828 assoc_line_out = assoc_speaker = 0; 2829 2830 end_nid = codec->start_nid + codec->num_nodes; 2831 for (nid = codec->start_nid; nid < end_nid; nid++) { 2832 unsigned int wid_caps = get_wcaps(codec, nid); 2833 unsigned int wid_type = 2834 (wid_caps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT; 2835 unsigned int def_conf; 2836 short assoc, loc; 2837 2838 /* read all default configuration for pin complex */ 2839 if (wid_type != AC_WID_PIN) 2840 continue; 2841 /* ignore the given nids (e.g. pc-beep returns error) */ 2842 if (ignore_nids && is_in_nid_list(nid, ignore_nids)) 2843 continue; 2844 2845 def_conf = snd_hda_codec_read(codec, nid, 0, 2846 AC_VERB_GET_CONFIG_DEFAULT, 0); 2847 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE) 2848 continue; 2849 loc = get_defcfg_location(def_conf); 2850 switch (get_defcfg_device(def_conf)) { 2851 case AC_JACK_LINE_OUT: 2852 seq = get_defcfg_sequence(def_conf); 2853 assoc = get_defcfg_association(def_conf); 2854 2855 if (!(wid_caps & AC_WCAP_STEREO)) 2856 if (!cfg->mono_out_pin) 2857 cfg->mono_out_pin = nid; 2858 if (!assoc) 2859 continue; 2860 if (!assoc_line_out) 2861 assoc_line_out = assoc; 2862 else if (assoc_line_out != assoc) 2863 continue; 2864 if (cfg->line_outs >= ARRAY_SIZE(cfg->line_out_pins)) 2865 continue; 2866 cfg->line_out_pins[cfg->line_outs] = nid; 2867 sequences_line_out[cfg->line_outs] = seq; 2868 cfg->line_outs++; 2869 break; 2870 case AC_JACK_SPEAKER: 2871 seq = get_defcfg_sequence(def_conf); 2872 assoc = get_defcfg_association(def_conf); 2873 if (! assoc) 2874 continue; 2875 if (! assoc_speaker) 2876 assoc_speaker = assoc; 2877 else if (assoc_speaker != assoc) 2878 continue; 2879 if (cfg->speaker_outs >= ARRAY_SIZE(cfg->speaker_pins)) 2880 continue; 2881 cfg->speaker_pins[cfg->speaker_outs] = nid; 2882 sequences_speaker[cfg->speaker_outs] = seq; 2883 cfg->speaker_outs++; 2884 break; 2885 case AC_JACK_HP_OUT: 2886 seq = get_defcfg_sequence(def_conf); 2887 assoc = get_defcfg_association(def_conf); 2888 if (cfg->hp_outs >= ARRAY_SIZE(cfg->hp_pins)) 2889 continue; 2890 cfg->hp_pins[cfg->hp_outs] = nid; 2891 sequences_hp[cfg->hp_outs] = (assoc << 4) | seq; 2892 cfg->hp_outs++; 2893 break; 2894 case AC_JACK_MIC_IN: { 2895 int preferred, alt; 2896 if (loc == AC_JACK_LOC_FRONT) { 2897 preferred = AUTO_PIN_FRONT_MIC; 2898 alt = AUTO_PIN_MIC; 2899 } else { 2900 preferred = AUTO_PIN_MIC; 2901 alt = AUTO_PIN_FRONT_MIC; 2902 } 2903 if (!cfg->input_pins[preferred]) 2904 cfg->input_pins[preferred] = nid; 2905 else if (!cfg->input_pins[alt]) 2906 cfg->input_pins[alt] = nid; 2907 break; 2908 } 2909 case AC_JACK_LINE_IN: 2910 if (loc == AC_JACK_LOC_FRONT) 2911 cfg->input_pins[AUTO_PIN_FRONT_LINE] = nid; 2912 else 2913 cfg->input_pins[AUTO_PIN_LINE] = nid; 2914 break; 2915 case AC_JACK_CD: 2916 cfg->input_pins[AUTO_PIN_CD] = nid; 2917 break; 2918 case AC_JACK_AUX: 2919 cfg->input_pins[AUTO_PIN_AUX] = nid; 2920 break; 2921 case AC_JACK_SPDIF_OUT: 2922 cfg->dig_out_pin = nid; 2923 break; 2924 case AC_JACK_SPDIF_IN: 2925 cfg->dig_in_pin = nid; 2926 break; 2927 } 2928 } 2929 2930 /* FIX-UP: 2931 * If no line-out is defined but multiple HPs are found, 2932 * some of them might be the real line-outs. 2933 */ 2934 if (!cfg->line_outs && cfg->hp_outs > 1) { 2935 int i = 0; 2936 while (i < cfg->hp_outs) { 2937 /* The real HPs should have the sequence 0x0f */ 2938 if ((sequences_hp[i] & 0x0f) == 0x0f) { 2939 i++; 2940 continue; 2941 } 2942 /* Move it to the line-out table */ 2943 cfg->line_out_pins[cfg->line_outs] = cfg->hp_pins[i]; 2944 sequences_line_out[cfg->line_outs] = sequences_hp[i]; 2945 cfg->line_outs++; 2946 cfg->hp_outs--; 2947 memmove(cfg->hp_pins + i, cfg->hp_pins + i + 1, 2948 sizeof(cfg->hp_pins[0]) * (cfg->hp_outs - i)); 2949 memmove(sequences_hp + i - 1, sequences_hp + i, 2950 sizeof(sequences_hp[0]) * (cfg->hp_outs - i)); 2951 } 2952 } 2953 2954 /* sort by sequence */ 2955 sort_pins_by_sequence(cfg->line_out_pins, sequences_line_out, 2956 cfg->line_outs); 2957 sort_pins_by_sequence(cfg->speaker_pins, sequences_speaker, 2958 cfg->speaker_outs); 2959 sort_pins_by_sequence(cfg->hp_pins, sequences_hp, 2960 cfg->hp_outs); 2961 2962 /* if we have only one mic, make it AUTO_PIN_MIC */ 2963 if (!cfg->input_pins[AUTO_PIN_MIC] && 2964 cfg->input_pins[AUTO_PIN_FRONT_MIC]) { 2965 cfg->input_pins[AUTO_PIN_MIC] = 2966 cfg->input_pins[AUTO_PIN_FRONT_MIC]; 2967 cfg->input_pins[AUTO_PIN_FRONT_MIC] = 0; 2968 } 2969 /* ditto for line-in */ 2970 if (!cfg->input_pins[AUTO_PIN_LINE] && 2971 cfg->input_pins[AUTO_PIN_FRONT_LINE]) { 2972 cfg->input_pins[AUTO_PIN_LINE] = 2973 cfg->input_pins[AUTO_PIN_FRONT_LINE]; 2974 cfg->input_pins[AUTO_PIN_FRONT_LINE] = 0; 2975 } 2976 2977 /* 2978 * FIX-UP: if no line-outs are detected, try to use speaker or HP pin 2979 * as a primary output 2980 */ 2981 if (!cfg->line_outs) { 2982 if (cfg->speaker_outs) { 2983 cfg->line_outs = cfg->speaker_outs; 2984 memcpy(cfg->line_out_pins, cfg->speaker_pins, 2985 sizeof(cfg->speaker_pins)); 2986 cfg->speaker_outs = 0; 2987 memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins)); 2988 cfg->line_out_type = AUTO_PIN_SPEAKER_OUT; 2989 } else if (cfg->hp_outs) { 2990 cfg->line_outs = cfg->hp_outs; 2991 memcpy(cfg->line_out_pins, cfg->hp_pins, 2992 sizeof(cfg->hp_pins)); 2993 cfg->hp_outs = 0; 2994 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins)); 2995 cfg->line_out_type = AUTO_PIN_HP_OUT; 2996 } 2997 } 2998 2999 /* Reorder the surround channels 3000 * ALSA sequence is front/surr/clfe/side 3001 * HDA sequence is: 3002 * 4-ch: front/surr => OK as it is 3003 * 6-ch: front/clfe/surr 3004 * 8-ch: front/clfe/rear/side|fc 3005 */ 3006 switch (cfg->line_outs) { 3007 case 3: 3008 case 4: 3009 nid = cfg->line_out_pins[1]; 3010 cfg->line_out_pins[1] = cfg->line_out_pins[2]; 3011 cfg->line_out_pins[2] = nid; 3012 break; 3013 } 3014 3015 /* 3016 * debug prints of the parsed results 3017 */ 3018 snd_printd("autoconfig: line_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n", 3019 cfg->line_outs, cfg->line_out_pins[0], cfg->line_out_pins[1], 3020 cfg->line_out_pins[2], cfg->line_out_pins[3], 3021 cfg->line_out_pins[4]); 3022 snd_printd(" speaker_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n", 3023 cfg->speaker_outs, cfg->speaker_pins[0], 3024 cfg->speaker_pins[1], cfg->speaker_pins[2], 3025 cfg->speaker_pins[3], cfg->speaker_pins[4]); 3026 snd_printd(" hp_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n", 3027 cfg->hp_outs, cfg->hp_pins[0], 3028 cfg->hp_pins[1], cfg->hp_pins[2], 3029 cfg->hp_pins[3], cfg->hp_pins[4]); 3030 snd_printd(" mono: mono_out=0x%x\n", cfg->mono_out_pin); 3031 snd_printd(" inputs: mic=0x%x, fmic=0x%x, line=0x%x, fline=0x%x," 3032 " cd=0x%x, aux=0x%x\n", 3033 cfg->input_pins[AUTO_PIN_MIC], 3034 cfg->input_pins[AUTO_PIN_FRONT_MIC], 3035 cfg->input_pins[AUTO_PIN_LINE], 3036 cfg->input_pins[AUTO_PIN_FRONT_LINE], 3037 cfg->input_pins[AUTO_PIN_CD], 3038 cfg->input_pins[AUTO_PIN_AUX]); 3039 3040 return 0; 3041 } 3042 3043 /* labels for input pins */ 3044 const char *auto_pin_cfg_labels[AUTO_PIN_LAST] = { 3045 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux" 3046 }; 3047 3048 3049 #ifdef CONFIG_PM 3050 /* 3051 * power management 3052 */ 3053 3054 /** 3055 * snd_hda_suspend - suspend the codecs 3056 * @bus: the HDA bus 3057 * @state: suspsend state 3058 * 3059 * Returns 0 if successful. 3060 */ 3061 int snd_hda_suspend(struct hda_bus *bus, pm_message_t state) 3062 { 3063 struct hda_codec *codec; 3064 3065 list_for_each_entry(codec, &bus->codec_list, list) { 3066 #ifdef CONFIG_SND_HDA_POWER_SAVE 3067 if (!codec->power_on) 3068 continue; 3069 #endif 3070 hda_call_codec_suspend(codec); 3071 } 3072 return 0; 3073 } 3074 3075 /** 3076 * snd_hda_resume - resume the codecs 3077 * @bus: the HDA bus 3078 * @state: resume state 3079 * 3080 * Returns 0 if successful. 3081 * 3082 * This fucntion is defined only when POWER_SAVE isn't set. 3083 * In the power-save mode, the codec is resumed dynamically. 3084 */ 3085 int snd_hda_resume(struct hda_bus *bus) 3086 { 3087 struct hda_codec *codec; 3088 3089 list_for_each_entry(codec, &bus->codec_list, list) { 3090 if (snd_hda_codec_needs_resume(codec)) 3091 hda_call_codec_resume(codec); 3092 } 3093 return 0; 3094 } 3095 #ifdef CONFIG_SND_HDA_POWER_SAVE 3096 int snd_hda_codecs_inuse(struct hda_bus *bus) 3097 { 3098 struct hda_codec *codec; 3099 3100 list_for_each_entry(codec, &bus->codec_list, list) { 3101 if (snd_hda_codec_needs_resume(codec)) 3102 return 1; 3103 } 3104 return 0; 3105 } 3106 #endif 3107 #endif 3108