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