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