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 /* 36 * vendor / preset table 37 */ 38 39 struct hda_vendor_id { 40 unsigned int id; 41 const char *name; 42 }; 43 44 /* codec vendor labels */ 45 static struct hda_vendor_id hda_vendor_ids[] = { 46 { 0x1002, "ATI" }, 47 { 0x1057, "Motorola" }, 48 { 0x1095, "Silicon Image" }, 49 { 0x10de, "Nvidia" }, 50 { 0x10ec, "Realtek" }, 51 { 0x1106, "VIA" }, 52 { 0x111d, "IDT" }, 53 { 0x11c1, "LSI" }, 54 { 0x11d4, "Analog Devices" }, 55 { 0x13f6, "C-Media" }, 56 { 0x14f1, "Conexant" }, 57 { 0x17e8, "Chrontel" }, 58 { 0x1854, "LG" }, 59 { 0x1aec, "Wolfson Microelectronics" }, 60 { 0x434d, "C-Media" }, 61 { 0x8086, "Intel" }, 62 { 0x8384, "SigmaTel" }, 63 {} /* terminator */ 64 }; 65 66 static DEFINE_MUTEX(preset_mutex); 67 static LIST_HEAD(hda_preset_tables); 68 69 int snd_hda_add_codec_preset(struct hda_codec_preset_list *preset) 70 { 71 mutex_lock(&preset_mutex); 72 list_add_tail(&preset->list, &hda_preset_tables); 73 mutex_unlock(&preset_mutex); 74 return 0; 75 } 76 EXPORT_SYMBOL_HDA(snd_hda_add_codec_preset); 77 78 int snd_hda_delete_codec_preset(struct hda_codec_preset_list *preset) 79 { 80 mutex_lock(&preset_mutex); 81 list_del(&preset->list); 82 mutex_unlock(&preset_mutex); 83 return 0; 84 } 85 EXPORT_SYMBOL_HDA(snd_hda_delete_codec_preset); 86 87 #ifdef CONFIG_SND_HDA_POWER_SAVE 88 static void hda_power_work(struct work_struct *work); 89 static void hda_keep_power_on(struct hda_codec *codec); 90 #else 91 static inline void hda_keep_power_on(struct hda_codec *codec) {} 92 #endif 93 94 const char *snd_hda_get_jack_location(u32 cfg) 95 { 96 static char *bases[7] = { 97 "N/A", "Rear", "Front", "Left", "Right", "Top", "Bottom", 98 }; 99 static unsigned char specials_idx[] = { 100 0x07, 0x08, 101 0x17, 0x18, 0x19, 102 0x37, 0x38 103 }; 104 static char *specials[] = { 105 "Rear Panel", "Drive Bar", 106 "Riser", "HDMI", "ATAPI", 107 "Mobile-In", "Mobile-Out" 108 }; 109 int i; 110 cfg = (cfg & AC_DEFCFG_LOCATION) >> AC_DEFCFG_LOCATION_SHIFT; 111 if ((cfg & 0x0f) < 7) 112 return bases[cfg & 0x0f]; 113 for (i = 0; i < ARRAY_SIZE(specials_idx); i++) { 114 if (cfg == specials_idx[i]) 115 return specials[i]; 116 } 117 return "UNKNOWN"; 118 } 119 EXPORT_SYMBOL_HDA(snd_hda_get_jack_location); 120 121 const char *snd_hda_get_jack_connectivity(u32 cfg) 122 { 123 static char *jack_locations[4] = { "Ext", "Int", "Sep", "Oth" }; 124 125 return jack_locations[(cfg >> (AC_DEFCFG_LOCATION_SHIFT + 4)) & 3]; 126 } 127 EXPORT_SYMBOL_HDA(snd_hda_get_jack_connectivity); 128 129 const char *snd_hda_get_jack_type(u32 cfg) 130 { 131 static char *jack_types[16] = { 132 "Line Out", "Speaker", "HP Out", "CD", 133 "SPDIF Out", "Digital Out", "Modem Line", "Modem Hand", 134 "Line In", "Aux", "Mic", "Telephony", 135 "SPDIF In", "Digitial In", "Reserved", "Other" 136 }; 137 138 return jack_types[(cfg & AC_DEFCFG_DEVICE) 139 >> AC_DEFCFG_DEVICE_SHIFT]; 140 } 141 EXPORT_SYMBOL_HDA(snd_hda_get_jack_type); 142 143 /* 144 * Compose a 32bit command word to be sent to the HD-audio controller 145 */ 146 static inline unsigned int 147 make_codec_cmd(struct hda_codec *codec, hda_nid_t nid, int direct, 148 unsigned int verb, unsigned int parm) 149 { 150 u32 val; 151 152 val = (u32)(codec->addr & 0x0f) << 28; 153 val |= (u32)direct << 27; 154 val |= (u32)nid << 20; 155 val |= verb << 8; 156 val |= parm; 157 return val; 158 } 159 160 /** 161 * snd_hda_codec_read - send a command and get the response 162 * @codec: the HDA codec 163 * @nid: NID to send the command 164 * @direct: direct flag 165 * @verb: the verb to send 166 * @parm: the parameter for the verb 167 * 168 * Send a single command and read the corresponding response. 169 * 170 * Returns the obtained response value, or -1 for an error. 171 */ 172 unsigned int snd_hda_codec_read(struct hda_codec *codec, hda_nid_t nid, 173 int direct, 174 unsigned int verb, unsigned int parm) 175 { 176 struct hda_bus *bus = codec->bus; 177 unsigned int res; 178 179 res = make_codec_cmd(codec, nid, direct, verb, parm); 180 snd_hda_power_up(codec); 181 mutex_lock(&bus->cmd_mutex); 182 if (!bus->ops.command(bus, res)) 183 res = bus->ops.get_response(bus); 184 else 185 res = (unsigned int)-1; 186 mutex_unlock(&bus->cmd_mutex); 187 snd_hda_power_down(codec); 188 return res; 189 } 190 EXPORT_SYMBOL_HDA(snd_hda_codec_read); 191 192 /** 193 * snd_hda_codec_write - send a single command without waiting for response 194 * @codec: the HDA codec 195 * @nid: NID to send the command 196 * @direct: direct flag 197 * @verb: the verb to send 198 * @parm: the parameter for the verb 199 * 200 * Send a single command without waiting for response. 201 * 202 * Returns 0 if successful, or a negative error code. 203 */ 204 int snd_hda_codec_write(struct hda_codec *codec, hda_nid_t nid, int direct, 205 unsigned int verb, unsigned int parm) 206 { 207 struct hda_bus *bus = codec->bus; 208 unsigned int res; 209 int err; 210 211 res = make_codec_cmd(codec, nid, direct, verb, parm); 212 snd_hda_power_up(codec); 213 mutex_lock(&bus->cmd_mutex); 214 err = bus->ops.command(bus, res); 215 mutex_unlock(&bus->cmd_mutex); 216 snd_hda_power_down(codec); 217 return err; 218 } 219 EXPORT_SYMBOL_HDA(snd_hda_codec_write); 220 221 /** 222 * snd_hda_sequence_write - sequence writes 223 * @codec: the HDA codec 224 * @seq: VERB array to send 225 * 226 * Send the commands sequentially from the given array. 227 * The array must be terminated with NID=0. 228 */ 229 void snd_hda_sequence_write(struct hda_codec *codec, const struct hda_verb *seq) 230 { 231 for (; seq->nid; seq++) 232 snd_hda_codec_write(codec, seq->nid, 0, seq->verb, seq->param); 233 } 234 EXPORT_SYMBOL_HDA(snd_hda_sequence_write); 235 236 /** 237 * snd_hda_get_sub_nodes - get the range of sub nodes 238 * @codec: the HDA codec 239 * @nid: NID to parse 240 * @start_id: the pointer to store the start NID 241 * 242 * Parse the NID and store the start NID of its sub-nodes. 243 * Returns the number of sub-nodes. 244 */ 245 int snd_hda_get_sub_nodes(struct hda_codec *codec, hda_nid_t nid, 246 hda_nid_t *start_id) 247 { 248 unsigned int parm; 249 250 parm = snd_hda_param_read(codec, nid, AC_PAR_NODE_COUNT); 251 if (parm == -1) 252 return 0; 253 *start_id = (parm >> 16) & 0x7fff; 254 return (int)(parm & 0x7fff); 255 } 256 EXPORT_SYMBOL_HDA(snd_hda_get_sub_nodes); 257 258 /** 259 * snd_hda_get_connections - get connection list 260 * @codec: the HDA codec 261 * @nid: NID to parse 262 * @conn_list: connection list array 263 * @max_conns: max. number of connections to store 264 * 265 * Parses the connection list of the given widget and stores the list 266 * of NIDs. 267 * 268 * Returns the number of connections, or a negative error code. 269 */ 270 int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid, 271 hda_nid_t *conn_list, int max_conns) 272 { 273 unsigned int parm; 274 int i, conn_len, conns; 275 unsigned int shift, num_elems, mask; 276 hda_nid_t prev_nid; 277 278 if (snd_BUG_ON(!conn_list || max_conns <= 0)) 279 return -EINVAL; 280 281 parm = snd_hda_param_read(codec, nid, AC_PAR_CONNLIST_LEN); 282 if (parm & AC_CLIST_LONG) { 283 /* long form */ 284 shift = 16; 285 num_elems = 2; 286 } else { 287 /* short form */ 288 shift = 8; 289 num_elems = 4; 290 } 291 conn_len = parm & AC_CLIST_LENGTH; 292 mask = (1 << (shift-1)) - 1; 293 294 if (!conn_len) 295 return 0; /* no connection */ 296 297 if (conn_len == 1) { 298 /* single connection */ 299 parm = snd_hda_codec_read(codec, nid, 0, 300 AC_VERB_GET_CONNECT_LIST, 0); 301 conn_list[0] = parm & mask; 302 return 1; 303 } 304 305 /* multi connection */ 306 conns = 0; 307 prev_nid = 0; 308 for (i = 0; i < conn_len; i++) { 309 int range_val; 310 hda_nid_t val, n; 311 312 if (i % num_elems == 0) 313 parm = snd_hda_codec_read(codec, nid, 0, 314 AC_VERB_GET_CONNECT_LIST, i); 315 range_val = !!(parm & (1 << (shift-1))); /* ranges */ 316 val = parm & mask; 317 parm >>= shift; 318 if (range_val) { 319 /* ranges between the previous and this one */ 320 if (!prev_nid || prev_nid >= val) { 321 snd_printk(KERN_WARNING "hda_codec: " 322 "invalid dep_range_val %x:%x\n", 323 prev_nid, val); 324 continue; 325 } 326 for (n = prev_nid + 1; n <= val; n++) { 327 if (conns >= max_conns) { 328 snd_printk(KERN_ERR 329 "Too many connections\n"); 330 return -EINVAL; 331 } 332 conn_list[conns++] = n; 333 } 334 } else { 335 if (conns >= max_conns) { 336 snd_printk(KERN_ERR "Too many connections\n"); 337 return -EINVAL; 338 } 339 conn_list[conns++] = val; 340 } 341 prev_nid = val; 342 } 343 return conns; 344 } 345 EXPORT_SYMBOL_HDA(snd_hda_get_connections); 346 347 348 /** 349 * snd_hda_queue_unsol_event - add an unsolicited event to queue 350 * @bus: the BUS 351 * @res: unsolicited event (lower 32bit of RIRB entry) 352 * @res_ex: codec addr and flags (upper 32bit or RIRB entry) 353 * 354 * Adds the given event to the queue. The events are processed in 355 * the workqueue asynchronously. Call this function in the interrupt 356 * hanlder when RIRB receives an unsolicited event. 357 * 358 * Returns 0 if successful, or a negative error code. 359 */ 360 int snd_hda_queue_unsol_event(struct hda_bus *bus, u32 res, u32 res_ex) 361 { 362 struct hda_bus_unsolicited *unsol; 363 unsigned int wp; 364 365 unsol = bus->unsol; 366 if (!unsol) 367 return 0; 368 369 wp = (unsol->wp + 1) % HDA_UNSOL_QUEUE_SIZE; 370 unsol->wp = wp; 371 372 wp <<= 1; 373 unsol->queue[wp] = res; 374 unsol->queue[wp + 1] = res_ex; 375 376 queue_work(bus->workq, &unsol->work); 377 378 return 0; 379 } 380 EXPORT_SYMBOL_HDA(snd_hda_queue_unsol_event); 381 382 /* 383 * process queued unsolicited events 384 */ 385 static void process_unsol_events(struct work_struct *work) 386 { 387 struct hda_bus_unsolicited *unsol = 388 container_of(work, struct hda_bus_unsolicited, work); 389 struct hda_bus *bus = unsol->bus; 390 struct hda_codec *codec; 391 unsigned int rp, caddr, res; 392 393 while (unsol->rp != unsol->wp) { 394 rp = (unsol->rp + 1) % HDA_UNSOL_QUEUE_SIZE; 395 unsol->rp = rp; 396 rp <<= 1; 397 res = unsol->queue[rp]; 398 caddr = unsol->queue[rp + 1]; 399 if (!(caddr & (1 << 4))) /* no unsolicited event? */ 400 continue; 401 codec = bus->caddr_tbl[caddr & 0x0f]; 402 if (codec && codec->patch_ops.unsol_event) 403 codec->patch_ops.unsol_event(codec, res); 404 } 405 } 406 407 /* 408 * initialize unsolicited queue 409 */ 410 static int init_unsol_queue(struct hda_bus *bus) 411 { 412 struct hda_bus_unsolicited *unsol; 413 414 if (bus->unsol) /* already initialized */ 415 return 0; 416 417 unsol = kzalloc(sizeof(*unsol), GFP_KERNEL); 418 if (!unsol) { 419 snd_printk(KERN_ERR "hda_codec: " 420 "can't allocate unsolicited queue\n"); 421 return -ENOMEM; 422 } 423 INIT_WORK(&unsol->work, process_unsol_events); 424 unsol->bus = bus; 425 bus->unsol = unsol; 426 return 0; 427 } 428 429 /* 430 * destructor 431 */ 432 static void snd_hda_codec_free(struct hda_codec *codec); 433 434 static int snd_hda_bus_free(struct hda_bus *bus) 435 { 436 struct hda_codec *codec, *n; 437 438 if (!bus) 439 return 0; 440 if (bus->workq) 441 flush_workqueue(bus->workq); 442 if (bus->unsol) 443 kfree(bus->unsol); 444 list_for_each_entry_safe(codec, n, &bus->codec_list, list) { 445 snd_hda_codec_free(codec); 446 } 447 if (bus->ops.private_free) 448 bus->ops.private_free(bus); 449 if (bus->workq) 450 destroy_workqueue(bus->workq); 451 kfree(bus); 452 return 0; 453 } 454 455 static int snd_hda_bus_dev_free(struct snd_device *device) 456 { 457 struct hda_bus *bus = device->device_data; 458 bus->shutdown = 1; 459 return snd_hda_bus_free(bus); 460 } 461 462 #ifdef CONFIG_SND_HDA_HWDEP 463 static int snd_hda_bus_dev_register(struct snd_device *device) 464 { 465 struct hda_bus *bus = device->device_data; 466 struct hda_codec *codec; 467 list_for_each_entry(codec, &bus->codec_list, list) { 468 snd_hda_hwdep_add_sysfs(codec); 469 } 470 return 0; 471 } 472 #else 473 #define snd_hda_bus_dev_register NULL 474 #endif 475 476 /** 477 * snd_hda_bus_new - create a HDA bus 478 * @card: the card entry 479 * @temp: the template for hda_bus information 480 * @busp: the pointer to store the created bus instance 481 * 482 * Returns 0 if successful, or a negative error code. 483 */ 484 int /*__devinit*/ snd_hda_bus_new(struct snd_card *card, 485 const struct hda_bus_template *temp, 486 struct hda_bus **busp) 487 { 488 struct hda_bus *bus; 489 int err; 490 static struct snd_device_ops dev_ops = { 491 .dev_register = snd_hda_bus_dev_register, 492 .dev_free = snd_hda_bus_dev_free, 493 }; 494 495 if (snd_BUG_ON(!temp)) 496 return -EINVAL; 497 if (snd_BUG_ON(!temp->ops.command || !temp->ops.get_response)) 498 return -EINVAL; 499 500 if (busp) 501 *busp = NULL; 502 503 bus = kzalloc(sizeof(*bus), GFP_KERNEL); 504 if (bus == NULL) { 505 snd_printk(KERN_ERR "can't allocate struct hda_bus\n"); 506 return -ENOMEM; 507 } 508 509 bus->card = card; 510 bus->private_data = temp->private_data; 511 bus->pci = temp->pci; 512 bus->modelname = temp->modelname; 513 bus->power_save = temp->power_save; 514 bus->ops = temp->ops; 515 516 mutex_init(&bus->cmd_mutex); 517 INIT_LIST_HEAD(&bus->codec_list); 518 519 snprintf(bus->workq_name, sizeof(bus->workq_name), 520 "hd-audio%d", card->number); 521 bus->workq = create_singlethread_workqueue(bus->workq_name); 522 if (!bus->workq) { 523 snd_printk(KERN_ERR "cannot create workqueue %s\n", 524 bus->workq_name); 525 kfree(bus); 526 return -ENOMEM; 527 } 528 529 err = snd_device_new(card, SNDRV_DEV_BUS, bus, &dev_ops); 530 if (err < 0) { 531 snd_hda_bus_free(bus); 532 return err; 533 } 534 if (busp) 535 *busp = bus; 536 return 0; 537 } 538 EXPORT_SYMBOL_HDA(snd_hda_bus_new); 539 540 #ifdef CONFIG_SND_HDA_GENERIC 541 #define is_generic_config(codec) \ 542 (codec->modelname && !strcmp(codec->modelname, "generic")) 543 #else 544 #define is_generic_config(codec) 0 545 #endif 546 547 #ifdef MODULE 548 #define HDA_MODREQ_MAX_COUNT 2 /* two request_modules()'s */ 549 #else 550 #define HDA_MODREQ_MAX_COUNT 0 /* all presets are statically linked */ 551 #endif 552 553 /* 554 * find a matching codec preset 555 */ 556 static const struct hda_codec_preset * 557 find_codec_preset(struct hda_codec *codec) 558 { 559 struct hda_codec_preset_list *tbl; 560 const struct hda_codec_preset *preset; 561 int mod_requested = 0; 562 563 if (is_generic_config(codec)) 564 return NULL; /* use the generic parser */ 565 566 again: 567 mutex_lock(&preset_mutex); 568 list_for_each_entry(tbl, &hda_preset_tables, list) { 569 if (!try_module_get(tbl->owner)) { 570 snd_printk(KERN_ERR "hda_codec: cannot module_get\n"); 571 continue; 572 } 573 for (preset = tbl->preset; preset->id; preset++) { 574 u32 mask = preset->mask; 575 if (preset->afg && preset->afg != codec->afg) 576 continue; 577 if (preset->mfg && preset->mfg != codec->mfg) 578 continue; 579 if (!mask) 580 mask = ~0; 581 if (preset->id == (codec->vendor_id & mask) && 582 (!preset->rev || 583 preset->rev == codec->revision_id)) { 584 mutex_unlock(&preset_mutex); 585 codec->owner = tbl->owner; 586 return preset; 587 } 588 } 589 module_put(tbl->owner); 590 } 591 mutex_unlock(&preset_mutex); 592 593 if (mod_requested < HDA_MODREQ_MAX_COUNT) { 594 char name[32]; 595 if (!mod_requested) 596 snprintf(name, sizeof(name), "snd-hda-codec-id:%08x", 597 codec->vendor_id); 598 else 599 snprintf(name, sizeof(name), "snd-hda-codec-id:%04x*", 600 (codec->vendor_id >> 16) & 0xffff); 601 request_module(name); 602 mod_requested++; 603 goto again; 604 } 605 return NULL; 606 } 607 608 /* 609 * get_codec_name - store the codec name 610 */ 611 static int get_codec_name(struct hda_codec *codec) 612 { 613 const struct hda_vendor_id *c; 614 const char *vendor = NULL; 615 u16 vendor_id = codec->vendor_id >> 16; 616 char tmp[16], name[32]; 617 618 for (c = hda_vendor_ids; c->id; c++) { 619 if (c->id == vendor_id) { 620 vendor = c->name; 621 break; 622 } 623 } 624 if (!vendor) { 625 sprintf(tmp, "Generic %04x", vendor_id); 626 vendor = tmp; 627 } 628 if (codec->preset && codec->preset->name) 629 snprintf(name, sizeof(name), "%s %s", vendor, 630 codec->preset->name); 631 else 632 snprintf(name, sizeof(name), "%s ID %x", vendor, 633 codec->vendor_id & 0xffff); 634 codec->name = kstrdup(name, GFP_KERNEL); 635 if (!codec->name) 636 return -ENOMEM; 637 return 0; 638 } 639 640 /* 641 * look for an AFG and MFG nodes 642 */ 643 static void /*__devinit*/ setup_fg_nodes(struct hda_codec *codec) 644 { 645 int i, total_nodes; 646 hda_nid_t nid; 647 648 total_nodes = snd_hda_get_sub_nodes(codec, AC_NODE_ROOT, &nid); 649 for (i = 0; i < total_nodes; i++, nid++) { 650 codec->function_id = snd_hda_param_read(codec, nid, 651 AC_PAR_FUNCTION_TYPE) & 0xff; 652 switch (codec->function_id) { 653 case AC_GRP_AUDIO_FUNCTION: 654 codec->afg = nid; 655 break; 656 case AC_GRP_MODEM_FUNCTION: 657 codec->mfg = nid; 658 break; 659 default: 660 break; 661 } 662 } 663 } 664 665 /* 666 * read widget caps for each widget and store in cache 667 */ 668 static int read_widget_caps(struct hda_codec *codec, hda_nid_t fg_node) 669 { 670 int i; 671 hda_nid_t nid; 672 673 codec->num_nodes = snd_hda_get_sub_nodes(codec, fg_node, 674 &codec->start_nid); 675 codec->wcaps = kmalloc(codec->num_nodes * 4, GFP_KERNEL); 676 if (!codec->wcaps) 677 return -ENOMEM; 678 nid = codec->start_nid; 679 for (i = 0; i < codec->num_nodes; i++, nid++) 680 codec->wcaps[i] = snd_hda_param_read(codec, nid, 681 AC_PAR_AUDIO_WIDGET_CAP); 682 return 0; 683 } 684 685 /* read all pin default configurations and save codec->init_pins */ 686 static int read_pin_defaults(struct hda_codec *codec) 687 { 688 int i; 689 hda_nid_t nid = codec->start_nid; 690 691 for (i = 0; i < codec->num_nodes; i++, nid++) { 692 struct hda_pincfg *pin; 693 unsigned int wcaps = get_wcaps(codec, nid); 694 unsigned int wid_type = (wcaps & AC_WCAP_TYPE) >> 695 AC_WCAP_TYPE_SHIFT; 696 if (wid_type != AC_WID_PIN) 697 continue; 698 pin = snd_array_new(&codec->init_pins); 699 if (!pin) 700 return -ENOMEM; 701 pin->nid = nid; 702 pin->cfg = snd_hda_codec_read(codec, nid, 0, 703 AC_VERB_GET_CONFIG_DEFAULT, 0); 704 } 705 return 0; 706 } 707 708 /* look up the given pin config list and return the item matching with NID */ 709 static struct hda_pincfg *look_up_pincfg(struct hda_codec *codec, 710 struct snd_array *array, 711 hda_nid_t nid) 712 { 713 int i; 714 for (i = 0; i < array->used; i++) { 715 struct hda_pincfg *pin = snd_array_elem(array, i); 716 if (pin->nid == nid) 717 return pin; 718 } 719 return NULL; 720 } 721 722 /* write a config value for the given NID */ 723 static void set_pincfg(struct hda_codec *codec, hda_nid_t nid, 724 unsigned int cfg) 725 { 726 int i; 727 for (i = 0; i < 4; i++) { 728 snd_hda_codec_write(codec, nid, 0, 729 AC_VERB_SET_CONFIG_DEFAULT_BYTES_0 + i, 730 cfg & 0xff); 731 cfg >>= 8; 732 } 733 } 734 735 /* set the current pin config value for the given NID. 736 * the value is cached, and read via snd_hda_codec_get_pincfg() 737 */ 738 int snd_hda_add_pincfg(struct hda_codec *codec, struct snd_array *list, 739 hda_nid_t nid, unsigned int cfg) 740 { 741 struct hda_pincfg *pin; 742 unsigned int oldcfg; 743 744 oldcfg = snd_hda_codec_get_pincfg(codec, nid); 745 pin = look_up_pincfg(codec, list, nid); 746 if (!pin) { 747 pin = snd_array_new(list); 748 if (!pin) 749 return -ENOMEM; 750 pin->nid = nid; 751 } 752 pin->cfg = cfg; 753 754 /* change only when needed; e.g. if the pincfg is already present 755 * in user_pins[], don't write it 756 */ 757 cfg = snd_hda_codec_get_pincfg(codec, nid); 758 if (oldcfg != cfg) 759 set_pincfg(codec, nid, cfg); 760 return 0; 761 } 762 763 int snd_hda_codec_set_pincfg(struct hda_codec *codec, 764 hda_nid_t nid, unsigned int cfg) 765 { 766 return snd_hda_add_pincfg(codec, &codec->driver_pins, nid, cfg); 767 } 768 EXPORT_SYMBOL_HDA(snd_hda_codec_set_pincfg); 769 770 /* get the current pin config value of the given pin NID */ 771 unsigned int snd_hda_codec_get_pincfg(struct hda_codec *codec, hda_nid_t nid) 772 { 773 struct hda_pincfg *pin; 774 775 #ifdef CONFIG_SND_HDA_HWDEP 776 pin = look_up_pincfg(codec, &codec->user_pins, nid); 777 if (pin) 778 return pin->cfg; 779 #endif 780 pin = look_up_pincfg(codec, &codec->driver_pins, nid); 781 if (pin) 782 return pin->cfg; 783 pin = look_up_pincfg(codec, &codec->init_pins, nid); 784 if (pin) 785 return pin->cfg; 786 return 0; 787 } 788 EXPORT_SYMBOL_HDA(snd_hda_codec_get_pincfg); 789 790 /* restore all current pin configs */ 791 static void restore_pincfgs(struct hda_codec *codec) 792 { 793 int i; 794 for (i = 0; i < codec->init_pins.used; i++) { 795 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i); 796 set_pincfg(codec, pin->nid, 797 snd_hda_codec_get_pincfg(codec, pin->nid)); 798 } 799 } 800 801 static void init_hda_cache(struct hda_cache_rec *cache, 802 unsigned int record_size); 803 static void free_hda_cache(struct hda_cache_rec *cache); 804 805 /* restore the initial pin cfgs and release all pincfg lists */ 806 static void restore_init_pincfgs(struct hda_codec *codec) 807 { 808 /* first free driver_pins and user_pins, then call restore_pincfg 809 * so that only the values in init_pins are restored 810 */ 811 snd_array_free(&codec->driver_pins); 812 #ifdef CONFIG_SND_HDA_HWDEP 813 snd_array_free(&codec->user_pins); 814 #endif 815 restore_pincfgs(codec); 816 snd_array_free(&codec->init_pins); 817 } 818 819 /* 820 * codec destructor 821 */ 822 static void snd_hda_codec_free(struct hda_codec *codec) 823 { 824 if (!codec) 825 return; 826 restore_init_pincfgs(codec); 827 #ifdef CONFIG_SND_HDA_POWER_SAVE 828 cancel_delayed_work(&codec->power_work); 829 flush_workqueue(codec->bus->workq); 830 #endif 831 list_del(&codec->list); 832 snd_array_free(&codec->mixers); 833 codec->bus->caddr_tbl[codec->addr] = NULL; 834 if (codec->patch_ops.free) 835 codec->patch_ops.free(codec); 836 module_put(codec->owner); 837 free_hda_cache(&codec->amp_cache); 838 free_hda_cache(&codec->cmd_cache); 839 kfree(codec->name); 840 kfree(codec->modelname); 841 kfree(codec->wcaps); 842 kfree(codec); 843 } 844 845 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg, 846 unsigned int power_state); 847 848 /** 849 * snd_hda_codec_new - create a HDA codec 850 * @bus: the bus to assign 851 * @codec_addr: the codec address 852 * @codecp: the pointer to store the generated codec 853 * 854 * Returns 0 if successful, or a negative error code. 855 */ 856 int /*__devinit*/ snd_hda_codec_new(struct hda_bus *bus, unsigned int codec_addr, 857 int do_init, struct hda_codec **codecp) 858 { 859 struct hda_codec *codec; 860 char component[31]; 861 int err; 862 863 if (snd_BUG_ON(!bus)) 864 return -EINVAL; 865 if (snd_BUG_ON(codec_addr > HDA_MAX_CODEC_ADDRESS)) 866 return -EINVAL; 867 868 if (bus->caddr_tbl[codec_addr]) { 869 snd_printk(KERN_ERR "hda_codec: " 870 "address 0x%x is already occupied\n", codec_addr); 871 return -EBUSY; 872 } 873 874 codec = kzalloc(sizeof(*codec), GFP_KERNEL); 875 if (codec == NULL) { 876 snd_printk(KERN_ERR "can't allocate struct hda_codec\n"); 877 return -ENOMEM; 878 } 879 880 codec->bus = bus; 881 codec->addr = codec_addr; 882 mutex_init(&codec->spdif_mutex); 883 mutex_init(&codec->control_mutex); 884 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info)); 885 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head)); 886 snd_array_init(&codec->mixers, sizeof(struct snd_kcontrol *), 32); 887 snd_array_init(&codec->init_pins, sizeof(struct hda_pincfg), 16); 888 snd_array_init(&codec->driver_pins, sizeof(struct hda_pincfg), 16); 889 if (codec->bus->modelname) { 890 codec->modelname = kstrdup(codec->bus->modelname, GFP_KERNEL); 891 if (!codec->modelname) { 892 snd_hda_codec_free(codec); 893 return -ENODEV; 894 } 895 } 896 897 #ifdef CONFIG_SND_HDA_POWER_SAVE 898 INIT_DELAYED_WORK(&codec->power_work, hda_power_work); 899 /* snd_hda_codec_new() marks the codec as power-up, and leave it as is. 900 * the caller has to power down appropriatley after initialization 901 * phase. 902 */ 903 hda_keep_power_on(codec); 904 #endif 905 906 list_add_tail(&codec->list, &bus->codec_list); 907 bus->caddr_tbl[codec_addr] = codec; 908 909 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT, 910 AC_PAR_VENDOR_ID); 911 if (codec->vendor_id == -1) 912 /* read again, hopefully the access method was corrected 913 * in the last read... 914 */ 915 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT, 916 AC_PAR_VENDOR_ID); 917 codec->subsystem_id = snd_hda_param_read(codec, AC_NODE_ROOT, 918 AC_PAR_SUBSYSTEM_ID); 919 codec->revision_id = snd_hda_param_read(codec, AC_NODE_ROOT, 920 AC_PAR_REV_ID); 921 922 setup_fg_nodes(codec); 923 if (!codec->afg && !codec->mfg) { 924 snd_printdd("hda_codec: no AFG or MFG node found\n"); 925 err = -ENODEV; 926 goto error; 927 } 928 929 err = read_widget_caps(codec, codec->afg ? codec->afg : codec->mfg); 930 if (err < 0) { 931 snd_printk(KERN_ERR "hda_codec: cannot malloc\n"); 932 goto error; 933 } 934 err = read_pin_defaults(codec); 935 if (err < 0) 936 goto error; 937 938 if (!codec->subsystem_id) { 939 hda_nid_t nid = codec->afg ? codec->afg : codec->mfg; 940 codec->subsystem_id = 941 snd_hda_codec_read(codec, nid, 0, 942 AC_VERB_GET_SUBSYSTEM_ID, 0); 943 } 944 if (bus->modelname) 945 codec->modelname = kstrdup(bus->modelname, GFP_KERNEL); 946 947 /* power-up all before initialization */ 948 hda_set_power_state(codec, 949 codec->afg ? codec->afg : codec->mfg, 950 AC_PWRST_D0); 951 952 if (do_init) { 953 err = snd_hda_codec_configure(codec); 954 if (err < 0) 955 goto error; 956 } 957 snd_hda_codec_proc_new(codec); 958 959 snd_hda_create_hwdep(codec); 960 961 sprintf(component, "HDA:%08x,%08x,%08x", codec->vendor_id, 962 codec->subsystem_id, codec->revision_id); 963 snd_component_add(codec->bus->card, component); 964 965 if (codecp) 966 *codecp = codec; 967 return 0; 968 969 error: 970 snd_hda_codec_free(codec); 971 return err; 972 } 973 EXPORT_SYMBOL_HDA(snd_hda_codec_new); 974 975 int snd_hda_codec_configure(struct hda_codec *codec) 976 { 977 int err; 978 979 codec->preset = find_codec_preset(codec); 980 if (!codec->name) { 981 err = get_codec_name(codec); 982 if (err < 0) 983 return err; 984 } 985 /* audio codec should override the mixer name */ 986 if (codec->afg || !*codec->bus->card->mixername) 987 strlcpy(codec->bus->card->mixername, codec->name, 988 sizeof(codec->bus->card->mixername)); 989 990 if (is_generic_config(codec)) { 991 err = snd_hda_parse_generic_codec(codec); 992 goto patched; 993 } 994 if (codec->preset && codec->preset->patch) { 995 err = codec->preset->patch(codec); 996 goto patched; 997 } 998 999 /* call the default parser */ 1000 err = snd_hda_parse_generic_codec(codec); 1001 if (err < 0) 1002 printk(KERN_ERR "hda-codec: No codec parser is available\n"); 1003 1004 patched: 1005 if (!err && codec->patch_ops.unsol_event) 1006 err = init_unsol_queue(codec->bus); 1007 return err; 1008 } 1009 1010 /** 1011 * snd_hda_codec_setup_stream - set up the codec for streaming 1012 * @codec: the CODEC to set up 1013 * @nid: the NID to set up 1014 * @stream_tag: stream tag to pass, it's between 0x1 and 0xf. 1015 * @channel_id: channel id to pass, zero based. 1016 * @format: stream format. 1017 */ 1018 void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid, 1019 u32 stream_tag, 1020 int channel_id, int format) 1021 { 1022 if (!nid) 1023 return; 1024 1025 snd_printdd("hda_codec_setup_stream: " 1026 "NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n", 1027 nid, stream_tag, channel_id, format); 1028 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 1029 (stream_tag << 4) | channel_id); 1030 msleep(1); 1031 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, format); 1032 } 1033 EXPORT_SYMBOL_HDA(snd_hda_codec_setup_stream); 1034 1035 void snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid) 1036 { 1037 if (!nid) 1038 return; 1039 1040 snd_printdd("hda_codec_cleanup_stream: NID=0x%x\n", nid); 1041 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 0); 1042 #if 0 /* keep the format */ 1043 msleep(1); 1044 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, 0); 1045 #endif 1046 } 1047 EXPORT_SYMBOL_HDA(snd_hda_codec_cleanup_stream); 1048 1049 /* 1050 * amp access functions 1051 */ 1052 1053 /* FIXME: more better hash key? */ 1054 #define HDA_HASH_KEY(nid,dir,idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24)) 1055 #define HDA_HASH_PINCAP_KEY(nid) (u32)((nid) + (0x02 << 24)) 1056 #define INFO_AMP_CAPS (1<<0) 1057 #define INFO_AMP_VOL(ch) (1 << (1 + (ch))) 1058 1059 /* initialize the hash table */ 1060 static void /*__devinit*/ init_hda_cache(struct hda_cache_rec *cache, 1061 unsigned int record_size) 1062 { 1063 memset(cache, 0, sizeof(*cache)); 1064 memset(cache->hash, 0xff, sizeof(cache->hash)); 1065 snd_array_init(&cache->buf, record_size, 64); 1066 } 1067 1068 static void free_hda_cache(struct hda_cache_rec *cache) 1069 { 1070 snd_array_free(&cache->buf); 1071 } 1072 1073 /* query the hash. allocate an entry if not found. */ 1074 static struct hda_cache_head *get_alloc_hash(struct hda_cache_rec *cache, 1075 u32 key) 1076 { 1077 u16 idx = key % (u16)ARRAY_SIZE(cache->hash); 1078 u16 cur = cache->hash[idx]; 1079 struct hda_cache_head *info; 1080 1081 while (cur != 0xffff) { 1082 info = snd_array_elem(&cache->buf, cur); 1083 if (info->key == key) 1084 return info; 1085 cur = info->next; 1086 } 1087 1088 /* add a new hash entry */ 1089 info = snd_array_new(&cache->buf); 1090 if (!info) 1091 return NULL; 1092 cur = snd_array_index(&cache->buf, info); 1093 info->key = key; 1094 info->val = 0; 1095 info->next = cache->hash[idx]; 1096 cache->hash[idx] = cur; 1097 1098 return info; 1099 } 1100 1101 /* query and allocate an amp hash entry */ 1102 static inline struct hda_amp_info * 1103 get_alloc_amp_hash(struct hda_codec *codec, u32 key) 1104 { 1105 return (struct hda_amp_info *)get_alloc_hash(&codec->amp_cache, key); 1106 } 1107 1108 /* 1109 * query AMP capabilities for the given widget and direction 1110 */ 1111 u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction) 1112 { 1113 struct hda_amp_info *info; 1114 1115 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, 0)); 1116 if (!info) 1117 return 0; 1118 if (!(info->head.val & INFO_AMP_CAPS)) { 1119 if (!(get_wcaps(codec, nid) & AC_WCAP_AMP_OVRD)) 1120 nid = codec->afg; 1121 info->amp_caps = snd_hda_param_read(codec, nid, 1122 direction == HDA_OUTPUT ? 1123 AC_PAR_AMP_OUT_CAP : 1124 AC_PAR_AMP_IN_CAP); 1125 if (info->amp_caps) 1126 info->head.val |= INFO_AMP_CAPS; 1127 } 1128 return info->amp_caps; 1129 } 1130 EXPORT_SYMBOL_HDA(query_amp_caps); 1131 1132 int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir, 1133 unsigned int caps) 1134 { 1135 struct hda_amp_info *info; 1136 1137 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, dir, 0)); 1138 if (!info) 1139 return -EINVAL; 1140 info->amp_caps = caps; 1141 info->head.val |= INFO_AMP_CAPS; 1142 return 0; 1143 } 1144 EXPORT_SYMBOL_HDA(snd_hda_override_amp_caps); 1145 1146 u32 snd_hda_query_pin_caps(struct hda_codec *codec, hda_nid_t nid) 1147 { 1148 struct hda_amp_info *info; 1149 1150 info = get_alloc_amp_hash(codec, HDA_HASH_PINCAP_KEY(nid)); 1151 if (!info) 1152 return 0; 1153 if (!info->head.val) { 1154 info->amp_caps = snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP); 1155 info->head.val |= INFO_AMP_CAPS; 1156 } 1157 return info->amp_caps; 1158 } 1159 EXPORT_SYMBOL_HDA(snd_hda_query_pin_caps); 1160 1161 /* 1162 * read the current volume to info 1163 * if the cache exists, read the cache value. 1164 */ 1165 static unsigned int get_vol_mute(struct hda_codec *codec, 1166 struct hda_amp_info *info, hda_nid_t nid, 1167 int ch, int direction, int index) 1168 { 1169 u32 val, parm; 1170 1171 if (info->head.val & INFO_AMP_VOL(ch)) 1172 return info->vol[ch]; 1173 1174 parm = ch ? AC_AMP_GET_RIGHT : AC_AMP_GET_LEFT; 1175 parm |= direction == HDA_OUTPUT ? AC_AMP_GET_OUTPUT : AC_AMP_GET_INPUT; 1176 parm |= index; 1177 val = snd_hda_codec_read(codec, nid, 0, 1178 AC_VERB_GET_AMP_GAIN_MUTE, parm); 1179 info->vol[ch] = val & 0xff; 1180 info->head.val |= INFO_AMP_VOL(ch); 1181 return info->vol[ch]; 1182 } 1183 1184 /* 1185 * write the current volume in info to the h/w and update the cache 1186 */ 1187 static void put_vol_mute(struct hda_codec *codec, struct hda_amp_info *info, 1188 hda_nid_t nid, int ch, int direction, int index, 1189 int val) 1190 { 1191 u32 parm; 1192 1193 parm = ch ? AC_AMP_SET_RIGHT : AC_AMP_SET_LEFT; 1194 parm |= direction == HDA_OUTPUT ? AC_AMP_SET_OUTPUT : AC_AMP_SET_INPUT; 1195 parm |= index << AC_AMP_SET_INDEX_SHIFT; 1196 parm |= val; 1197 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, parm); 1198 info->vol[ch] = val; 1199 } 1200 1201 /* 1202 * read AMP value. The volume is between 0 to 0x7f, 0x80 = mute bit. 1203 */ 1204 int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch, 1205 int direction, int index) 1206 { 1207 struct hda_amp_info *info; 1208 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, index)); 1209 if (!info) 1210 return 0; 1211 return get_vol_mute(codec, info, nid, ch, direction, index); 1212 } 1213 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_read); 1214 1215 /* 1216 * update the AMP value, mask = bit mask to set, val = the value 1217 */ 1218 int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch, 1219 int direction, int idx, int mask, int val) 1220 { 1221 struct hda_amp_info *info; 1222 1223 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, idx)); 1224 if (!info) 1225 return 0; 1226 val &= mask; 1227 val |= get_vol_mute(codec, info, nid, ch, direction, idx) & ~mask; 1228 if (info->vol[ch] == val) 1229 return 0; 1230 put_vol_mute(codec, info, nid, ch, direction, idx, val); 1231 return 1; 1232 } 1233 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_update); 1234 1235 /* 1236 * update the AMP stereo with the same mask and value 1237 */ 1238 int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid, 1239 int direction, int idx, int mask, int val) 1240 { 1241 int ch, ret = 0; 1242 for (ch = 0; ch < 2; ch++) 1243 ret |= snd_hda_codec_amp_update(codec, nid, ch, direction, 1244 idx, mask, val); 1245 return ret; 1246 } 1247 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_stereo); 1248 1249 #ifdef SND_HDA_NEEDS_RESUME 1250 /* resume the all amp commands from the cache */ 1251 void snd_hda_codec_resume_amp(struct hda_codec *codec) 1252 { 1253 struct hda_amp_info *buffer = codec->amp_cache.buf.list; 1254 int i; 1255 1256 for (i = 0; i < codec->amp_cache.buf.used; i++, buffer++) { 1257 u32 key = buffer->head.key; 1258 hda_nid_t nid; 1259 unsigned int idx, dir, ch; 1260 if (!key) 1261 continue; 1262 nid = key & 0xff; 1263 idx = (key >> 16) & 0xff; 1264 dir = (key >> 24) & 0xff; 1265 for (ch = 0; ch < 2; ch++) { 1266 if (!(buffer->head.val & INFO_AMP_VOL(ch))) 1267 continue; 1268 put_vol_mute(codec, buffer, nid, ch, dir, idx, 1269 buffer->vol[ch]); 1270 } 1271 } 1272 } 1273 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_amp); 1274 #endif /* SND_HDA_NEEDS_RESUME */ 1275 1276 /* volume */ 1277 int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol, 1278 struct snd_ctl_elem_info *uinfo) 1279 { 1280 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1281 u16 nid = get_amp_nid(kcontrol); 1282 u8 chs = get_amp_channels(kcontrol); 1283 int dir = get_amp_direction(kcontrol); 1284 unsigned int ofs = get_amp_offset(kcontrol); 1285 u32 caps; 1286 1287 caps = query_amp_caps(codec, nid, dir); 1288 /* num steps */ 1289 caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT; 1290 if (!caps) { 1291 printk(KERN_WARNING "hda_codec: " 1292 "num_steps = 0 for NID=0x%x (ctl = %s)\n", nid, 1293 kcontrol->id.name); 1294 return -EINVAL; 1295 } 1296 if (ofs < caps) 1297 caps -= ofs; 1298 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 1299 uinfo->count = chs == 3 ? 2 : 1; 1300 uinfo->value.integer.min = 0; 1301 uinfo->value.integer.max = caps; 1302 return 0; 1303 } 1304 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_info); 1305 1306 1307 static inline unsigned int 1308 read_amp_value(struct hda_codec *codec, hda_nid_t nid, 1309 int ch, int dir, int idx, unsigned int ofs) 1310 { 1311 unsigned int val; 1312 val = snd_hda_codec_amp_read(codec, nid, ch, dir, idx); 1313 val &= HDA_AMP_VOLMASK; 1314 if (val >= ofs) 1315 val -= ofs; 1316 else 1317 val = 0; 1318 return val; 1319 } 1320 1321 static inline int 1322 update_amp_value(struct hda_codec *codec, hda_nid_t nid, 1323 int ch, int dir, int idx, unsigned int ofs, 1324 unsigned int val) 1325 { 1326 if (val > 0) 1327 val += ofs; 1328 return snd_hda_codec_amp_update(codec, nid, ch, dir, idx, 1329 HDA_AMP_VOLMASK, val); 1330 } 1331 1332 int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol, 1333 struct snd_ctl_elem_value *ucontrol) 1334 { 1335 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1336 hda_nid_t nid = get_amp_nid(kcontrol); 1337 int chs = get_amp_channels(kcontrol); 1338 int dir = get_amp_direction(kcontrol); 1339 int idx = get_amp_index(kcontrol); 1340 unsigned int ofs = get_amp_offset(kcontrol); 1341 long *valp = ucontrol->value.integer.value; 1342 1343 if (chs & 1) 1344 *valp++ = read_amp_value(codec, nid, 0, dir, idx, ofs); 1345 if (chs & 2) 1346 *valp = read_amp_value(codec, nid, 1, dir, idx, ofs); 1347 return 0; 1348 } 1349 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_get); 1350 1351 int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol, 1352 struct snd_ctl_elem_value *ucontrol) 1353 { 1354 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1355 hda_nid_t nid = get_amp_nid(kcontrol); 1356 int chs = get_amp_channels(kcontrol); 1357 int dir = get_amp_direction(kcontrol); 1358 int idx = get_amp_index(kcontrol); 1359 unsigned int ofs = get_amp_offset(kcontrol); 1360 long *valp = ucontrol->value.integer.value; 1361 int change = 0; 1362 1363 snd_hda_power_up(codec); 1364 if (chs & 1) { 1365 change = update_amp_value(codec, nid, 0, dir, idx, ofs, *valp); 1366 valp++; 1367 } 1368 if (chs & 2) 1369 change |= update_amp_value(codec, nid, 1, dir, idx, ofs, *valp); 1370 snd_hda_power_down(codec); 1371 return change; 1372 } 1373 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_put); 1374 1375 int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag, 1376 unsigned int size, unsigned int __user *_tlv) 1377 { 1378 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1379 hda_nid_t nid = get_amp_nid(kcontrol); 1380 int dir = get_amp_direction(kcontrol); 1381 unsigned int ofs = get_amp_offset(kcontrol); 1382 u32 caps, val1, val2; 1383 1384 if (size < 4 * sizeof(unsigned int)) 1385 return -ENOMEM; 1386 caps = query_amp_caps(codec, nid, dir); 1387 val2 = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT; 1388 val2 = (val2 + 1) * 25; 1389 val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT); 1390 val1 += ofs; 1391 val1 = ((int)val1) * ((int)val2); 1392 if (put_user(SNDRV_CTL_TLVT_DB_SCALE, _tlv)) 1393 return -EFAULT; 1394 if (put_user(2 * sizeof(unsigned int), _tlv + 1)) 1395 return -EFAULT; 1396 if (put_user(val1, _tlv + 2)) 1397 return -EFAULT; 1398 if (put_user(val2, _tlv + 3)) 1399 return -EFAULT; 1400 return 0; 1401 } 1402 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_tlv); 1403 1404 /* 1405 * set (static) TLV for virtual master volume; recalculated as max 0dB 1406 */ 1407 void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir, 1408 unsigned int *tlv) 1409 { 1410 u32 caps; 1411 int nums, step; 1412 1413 caps = query_amp_caps(codec, nid, dir); 1414 nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT; 1415 step = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT; 1416 step = (step + 1) * 25; 1417 tlv[0] = SNDRV_CTL_TLVT_DB_SCALE; 1418 tlv[1] = 2 * sizeof(unsigned int); 1419 tlv[2] = -nums * step; 1420 tlv[3] = step; 1421 } 1422 EXPORT_SYMBOL_HDA(snd_hda_set_vmaster_tlv); 1423 1424 /* find a mixer control element with the given name */ 1425 static struct snd_kcontrol * 1426 _snd_hda_find_mixer_ctl(struct hda_codec *codec, 1427 const char *name, int idx) 1428 { 1429 struct snd_ctl_elem_id id; 1430 memset(&id, 0, sizeof(id)); 1431 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER; 1432 id.index = idx; 1433 strcpy(id.name, name); 1434 return snd_ctl_find_id(codec->bus->card, &id); 1435 } 1436 1437 struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec, 1438 const char *name) 1439 { 1440 return _snd_hda_find_mixer_ctl(codec, name, 0); 1441 } 1442 EXPORT_SYMBOL_HDA(snd_hda_find_mixer_ctl); 1443 1444 /* Add a control element and assign to the codec */ 1445 int snd_hda_ctl_add(struct hda_codec *codec, struct snd_kcontrol *kctl) 1446 { 1447 int err; 1448 struct snd_kcontrol **knewp; 1449 1450 err = snd_ctl_add(codec->bus->card, kctl); 1451 if (err < 0) 1452 return err; 1453 knewp = snd_array_new(&codec->mixers); 1454 if (!knewp) 1455 return -ENOMEM; 1456 *knewp = kctl; 1457 return 0; 1458 } 1459 EXPORT_SYMBOL_HDA(snd_hda_ctl_add); 1460 1461 /* Clear all controls assigned to the given codec */ 1462 void snd_hda_ctls_clear(struct hda_codec *codec) 1463 { 1464 int i; 1465 struct snd_kcontrol **kctls = codec->mixers.list; 1466 for (i = 0; i < codec->mixers.used; i++) 1467 snd_ctl_remove(codec->bus->card, kctls[i]); 1468 snd_array_free(&codec->mixers); 1469 } 1470 1471 /* pseudo device locking 1472 * toggle card->shutdown to allow/disallow the device access (as a hack) 1473 */ 1474 static int hda_lock_devices(struct snd_card *card) 1475 { 1476 spin_lock(&card->files_lock); 1477 if (card->shutdown) { 1478 spin_unlock(&card->files_lock); 1479 return -EINVAL; 1480 } 1481 card->shutdown = 1; 1482 spin_unlock(&card->files_lock); 1483 return 0; 1484 } 1485 1486 static void hda_unlock_devices(struct snd_card *card) 1487 { 1488 spin_lock(&card->files_lock); 1489 card->shutdown = 0; 1490 spin_unlock(&card->files_lock); 1491 } 1492 1493 int snd_hda_codec_reset(struct hda_codec *codec) 1494 { 1495 struct snd_card *card = codec->bus->card; 1496 int i, pcm; 1497 1498 if (hda_lock_devices(card) < 0) 1499 return -EBUSY; 1500 /* check whether the codec isn't used by any mixer or PCM streams */ 1501 if (!list_empty(&card->ctl_files)) { 1502 hda_unlock_devices(card); 1503 return -EBUSY; 1504 } 1505 for (pcm = 0; pcm < codec->num_pcms; pcm++) { 1506 struct hda_pcm *cpcm = &codec->pcm_info[pcm]; 1507 if (!cpcm->pcm) 1508 continue; 1509 if (cpcm->pcm->streams[0].substream_opened || 1510 cpcm->pcm->streams[1].substream_opened) { 1511 hda_unlock_devices(card); 1512 return -EBUSY; 1513 } 1514 } 1515 1516 /* OK, let it free */ 1517 1518 #ifdef CONFIG_SND_HDA_POWER_SAVE 1519 cancel_delayed_work(&codec->power_work); 1520 flush_workqueue(codec->bus->workq); 1521 #endif 1522 snd_hda_ctls_clear(codec); 1523 /* relase PCMs */ 1524 for (i = 0; i < codec->num_pcms; i++) { 1525 if (codec->pcm_info[i].pcm) { 1526 snd_device_free(card, codec->pcm_info[i].pcm); 1527 clear_bit(codec->pcm_info[i].device, 1528 codec->bus->pcm_dev_bits); 1529 } 1530 } 1531 if (codec->patch_ops.free) 1532 codec->patch_ops.free(codec); 1533 codec->proc_widget_hook = NULL; 1534 codec->spec = NULL; 1535 free_hda_cache(&codec->amp_cache); 1536 free_hda_cache(&codec->cmd_cache); 1537 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info)); 1538 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head)); 1539 /* free only driver_pins so that init_pins + user_pins are restored */ 1540 snd_array_free(&codec->driver_pins); 1541 restore_pincfgs(codec); 1542 codec->num_pcms = 0; 1543 codec->pcm_info = NULL; 1544 codec->preset = NULL; 1545 memset(&codec->patch_ops, 0, sizeof(codec->patch_ops)); 1546 codec->slave_dig_outs = NULL; 1547 codec->spdif_status_reset = 0; 1548 module_put(codec->owner); 1549 codec->owner = NULL; 1550 1551 /* allow device access again */ 1552 hda_unlock_devices(card); 1553 return 0; 1554 } 1555 1556 /* create a virtual master control and add slaves */ 1557 int snd_hda_add_vmaster(struct hda_codec *codec, char *name, 1558 unsigned int *tlv, const char **slaves) 1559 { 1560 struct snd_kcontrol *kctl; 1561 const char **s; 1562 int err; 1563 1564 for (s = slaves; *s && !snd_hda_find_mixer_ctl(codec, *s); s++) 1565 ; 1566 if (!*s) { 1567 snd_printdd("No slave found for %s\n", name); 1568 return 0; 1569 } 1570 kctl = snd_ctl_make_virtual_master(name, tlv); 1571 if (!kctl) 1572 return -ENOMEM; 1573 err = snd_hda_ctl_add(codec, kctl); 1574 if (err < 0) 1575 return err; 1576 1577 for (s = slaves; *s; s++) { 1578 struct snd_kcontrol *sctl; 1579 int i = 0; 1580 for (;;) { 1581 sctl = _snd_hda_find_mixer_ctl(codec, *s, i); 1582 if (!sctl) { 1583 if (!i) 1584 snd_printdd("Cannot find slave %s, " 1585 "skipped\n", *s); 1586 break; 1587 } 1588 err = snd_ctl_add_slave(kctl, sctl); 1589 if (err < 0) 1590 return err; 1591 i++; 1592 } 1593 } 1594 return 0; 1595 } 1596 EXPORT_SYMBOL_HDA(snd_hda_add_vmaster); 1597 1598 /* switch */ 1599 int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol, 1600 struct snd_ctl_elem_info *uinfo) 1601 { 1602 int chs = get_amp_channels(kcontrol); 1603 1604 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; 1605 uinfo->count = chs == 3 ? 2 : 1; 1606 uinfo->value.integer.min = 0; 1607 uinfo->value.integer.max = 1; 1608 return 0; 1609 } 1610 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_info); 1611 1612 int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol, 1613 struct snd_ctl_elem_value *ucontrol) 1614 { 1615 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1616 hda_nid_t nid = get_amp_nid(kcontrol); 1617 int chs = get_amp_channels(kcontrol); 1618 int dir = get_amp_direction(kcontrol); 1619 int idx = get_amp_index(kcontrol); 1620 long *valp = ucontrol->value.integer.value; 1621 1622 if (chs & 1) 1623 *valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) & 1624 HDA_AMP_MUTE) ? 0 : 1; 1625 if (chs & 2) 1626 *valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) & 1627 HDA_AMP_MUTE) ? 0 : 1; 1628 return 0; 1629 } 1630 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_get); 1631 1632 int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol, 1633 struct snd_ctl_elem_value *ucontrol) 1634 { 1635 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1636 hda_nid_t nid = get_amp_nid(kcontrol); 1637 int chs = get_amp_channels(kcontrol); 1638 int dir = get_amp_direction(kcontrol); 1639 int idx = get_amp_index(kcontrol); 1640 long *valp = ucontrol->value.integer.value; 1641 int change = 0; 1642 1643 snd_hda_power_up(codec); 1644 if (chs & 1) { 1645 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx, 1646 HDA_AMP_MUTE, 1647 *valp ? 0 : HDA_AMP_MUTE); 1648 valp++; 1649 } 1650 if (chs & 2) 1651 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx, 1652 HDA_AMP_MUTE, 1653 *valp ? 0 : HDA_AMP_MUTE); 1654 #ifdef CONFIG_SND_HDA_POWER_SAVE 1655 if (codec->patch_ops.check_power_status) 1656 codec->patch_ops.check_power_status(codec, nid); 1657 #endif 1658 snd_hda_power_down(codec); 1659 return change; 1660 } 1661 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put); 1662 1663 /* 1664 * bound volume controls 1665 * 1666 * bind multiple volumes (# indices, from 0) 1667 */ 1668 1669 #define AMP_VAL_IDX_SHIFT 19 1670 #define AMP_VAL_IDX_MASK (0x0f<<19) 1671 1672 int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol, 1673 struct snd_ctl_elem_value *ucontrol) 1674 { 1675 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1676 unsigned long pval; 1677 int err; 1678 1679 mutex_lock(&codec->control_mutex); 1680 pval = kcontrol->private_value; 1681 kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */ 1682 err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol); 1683 kcontrol->private_value = pval; 1684 mutex_unlock(&codec->control_mutex); 1685 return err; 1686 } 1687 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_get); 1688 1689 int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol, 1690 struct snd_ctl_elem_value *ucontrol) 1691 { 1692 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1693 unsigned long pval; 1694 int i, indices, err = 0, change = 0; 1695 1696 mutex_lock(&codec->control_mutex); 1697 pval = kcontrol->private_value; 1698 indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT; 1699 for (i = 0; i < indices; i++) { 1700 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) | 1701 (i << AMP_VAL_IDX_SHIFT); 1702 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol); 1703 if (err < 0) 1704 break; 1705 change |= err; 1706 } 1707 kcontrol->private_value = pval; 1708 mutex_unlock(&codec->control_mutex); 1709 return err < 0 ? err : change; 1710 } 1711 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_put); 1712 1713 /* 1714 * generic bound volume/swtich controls 1715 */ 1716 int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol, 1717 struct snd_ctl_elem_info *uinfo) 1718 { 1719 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1720 struct hda_bind_ctls *c; 1721 int err; 1722 1723 mutex_lock(&codec->control_mutex); 1724 c = (struct hda_bind_ctls *)kcontrol->private_value; 1725 kcontrol->private_value = *c->values; 1726 err = c->ops->info(kcontrol, uinfo); 1727 kcontrol->private_value = (long)c; 1728 mutex_unlock(&codec->control_mutex); 1729 return err; 1730 } 1731 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_info); 1732 1733 int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol, 1734 struct snd_ctl_elem_value *ucontrol) 1735 { 1736 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1737 struct hda_bind_ctls *c; 1738 int err; 1739 1740 mutex_lock(&codec->control_mutex); 1741 c = (struct hda_bind_ctls *)kcontrol->private_value; 1742 kcontrol->private_value = *c->values; 1743 err = c->ops->get(kcontrol, ucontrol); 1744 kcontrol->private_value = (long)c; 1745 mutex_unlock(&codec->control_mutex); 1746 return err; 1747 } 1748 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_get); 1749 1750 int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol, 1751 struct snd_ctl_elem_value *ucontrol) 1752 { 1753 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1754 struct hda_bind_ctls *c; 1755 unsigned long *vals; 1756 int err = 0, change = 0; 1757 1758 mutex_lock(&codec->control_mutex); 1759 c = (struct hda_bind_ctls *)kcontrol->private_value; 1760 for (vals = c->values; *vals; vals++) { 1761 kcontrol->private_value = *vals; 1762 err = c->ops->put(kcontrol, ucontrol); 1763 if (err < 0) 1764 break; 1765 change |= err; 1766 } 1767 kcontrol->private_value = (long)c; 1768 mutex_unlock(&codec->control_mutex); 1769 return err < 0 ? err : change; 1770 } 1771 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_put); 1772 1773 int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag, 1774 unsigned int size, unsigned int __user *tlv) 1775 { 1776 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1777 struct hda_bind_ctls *c; 1778 int err; 1779 1780 mutex_lock(&codec->control_mutex); 1781 c = (struct hda_bind_ctls *)kcontrol->private_value; 1782 kcontrol->private_value = *c->values; 1783 err = c->ops->tlv(kcontrol, op_flag, size, tlv); 1784 kcontrol->private_value = (long)c; 1785 mutex_unlock(&codec->control_mutex); 1786 return err; 1787 } 1788 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_tlv); 1789 1790 struct hda_ctl_ops snd_hda_bind_vol = { 1791 .info = snd_hda_mixer_amp_volume_info, 1792 .get = snd_hda_mixer_amp_volume_get, 1793 .put = snd_hda_mixer_amp_volume_put, 1794 .tlv = snd_hda_mixer_amp_tlv 1795 }; 1796 EXPORT_SYMBOL_HDA(snd_hda_bind_vol); 1797 1798 struct hda_ctl_ops snd_hda_bind_sw = { 1799 .info = snd_hda_mixer_amp_switch_info, 1800 .get = snd_hda_mixer_amp_switch_get, 1801 .put = snd_hda_mixer_amp_switch_put, 1802 .tlv = snd_hda_mixer_amp_tlv 1803 }; 1804 EXPORT_SYMBOL_HDA(snd_hda_bind_sw); 1805 1806 /* 1807 * SPDIF out controls 1808 */ 1809 1810 static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol, 1811 struct snd_ctl_elem_info *uinfo) 1812 { 1813 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; 1814 uinfo->count = 1; 1815 return 0; 1816 } 1817 1818 static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol, 1819 struct snd_ctl_elem_value *ucontrol) 1820 { 1821 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL | 1822 IEC958_AES0_NONAUDIO | 1823 IEC958_AES0_CON_EMPHASIS_5015 | 1824 IEC958_AES0_CON_NOT_COPYRIGHT; 1825 ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY | 1826 IEC958_AES1_CON_ORIGINAL; 1827 return 0; 1828 } 1829 1830 static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol, 1831 struct snd_ctl_elem_value *ucontrol) 1832 { 1833 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL | 1834 IEC958_AES0_NONAUDIO | 1835 IEC958_AES0_PRO_EMPHASIS_5015; 1836 return 0; 1837 } 1838 1839 static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol, 1840 struct snd_ctl_elem_value *ucontrol) 1841 { 1842 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1843 1844 ucontrol->value.iec958.status[0] = codec->spdif_status & 0xff; 1845 ucontrol->value.iec958.status[1] = (codec->spdif_status >> 8) & 0xff; 1846 ucontrol->value.iec958.status[2] = (codec->spdif_status >> 16) & 0xff; 1847 ucontrol->value.iec958.status[3] = (codec->spdif_status >> 24) & 0xff; 1848 1849 return 0; 1850 } 1851 1852 /* convert from SPDIF status bits to HDA SPDIF bits 1853 * bit 0 (DigEn) is always set zero (to be filled later) 1854 */ 1855 static unsigned short convert_from_spdif_status(unsigned int sbits) 1856 { 1857 unsigned short val = 0; 1858 1859 if (sbits & IEC958_AES0_PROFESSIONAL) 1860 val |= AC_DIG1_PROFESSIONAL; 1861 if (sbits & IEC958_AES0_NONAUDIO) 1862 val |= AC_DIG1_NONAUDIO; 1863 if (sbits & IEC958_AES0_PROFESSIONAL) { 1864 if ((sbits & IEC958_AES0_PRO_EMPHASIS) == 1865 IEC958_AES0_PRO_EMPHASIS_5015) 1866 val |= AC_DIG1_EMPHASIS; 1867 } else { 1868 if ((sbits & IEC958_AES0_CON_EMPHASIS) == 1869 IEC958_AES0_CON_EMPHASIS_5015) 1870 val |= AC_DIG1_EMPHASIS; 1871 if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT)) 1872 val |= AC_DIG1_COPYRIGHT; 1873 if (sbits & (IEC958_AES1_CON_ORIGINAL << 8)) 1874 val |= AC_DIG1_LEVEL; 1875 val |= sbits & (IEC958_AES1_CON_CATEGORY << 8); 1876 } 1877 return val; 1878 } 1879 1880 /* convert to SPDIF status bits from HDA SPDIF bits 1881 */ 1882 static unsigned int convert_to_spdif_status(unsigned short val) 1883 { 1884 unsigned int sbits = 0; 1885 1886 if (val & AC_DIG1_NONAUDIO) 1887 sbits |= IEC958_AES0_NONAUDIO; 1888 if (val & AC_DIG1_PROFESSIONAL) 1889 sbits |= IEC958_AES0_PROFESSIONAL; 1890 if (sbits & IEC958_AES0_PROFESSIONAL) { 1891 if (sbits & AC_DIG1_EMPHASIS) 1892 sbits |= IEC958_AES0_PRO_EMPHASIS_5015; 1893 } else { 1894 if (val & AC_DIG1_EMPHASIS) 1895 sbits |= IEC958_AES0_CON_EMPHASIS_5015; 1896 if (!(val & AC_DIG1_COPYRIGHT)) 1897 sbits |= IEC958_AES0_CON_NOT_COPYRIGHT; 1898 if (val & AC_DIG1_LEVEL) 1899 sbits |= (IEC958_AES1_CON_ORIGINAL << 8); 1900 sbits |= val & (0x7f << 8); 1901 } 1902 return sbits; 1903 } 1904 1905 /* set digital convert verbs both for the given NID and its slaves */ 1906 static void set_dig_out(struct hda_codec *codec, hda_nid_t nid, 1907 int verb, int val) 1908 { 1909 hda_nid_t *d; 1910 1911 snd_hda_codec_write_cache(codec, nid, 0, verb, val); 1912 d = codec->slave_dig_outs; 1913 if (!d) 1914 return; 1915 for (; *d; d++) 1916 snd_hda_codec_write_cache(codec, *d, 0, verb, val); 1917 } 1918 1919 static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid, 1920 int dig1, int dig2) 1921 { 1922 if (dig1 != -1) 1923 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_1, dig1); 1924 if (dig2 != -1) 1925 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_2, dig2); 1926 } 1927 1928 static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol, 1929 struct snd_ctl_elem_value *ucontrol) 1930 { 1931 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1932 hda_nid_t nid = kcontrol->private_value; 1933 unsigned short val; 1934 int change; 1935 1936 mutex_lock(&codec->spdif_mutex); 1937 codec->spdif_status = ucontrol->value.iec958.status[0] | 1938 ((unsigned int)ucontrol->value.iec958.status[1] << 8) | 1939 ((unsigned int)ucontrol->value.iec958.status[2] << 16) | 1940 ((unsigned int)ucontrol->value.iec958.status[3] << 24); 1941 val = convert_from_spdif_status(codec->spdif_status); 1942 val |= codec->spdif_ctls & 1; 1943 change = codec->spdif_ctls != val; 1944 codec->spdif_ctls = val; 1945 1946 if (change) 1947 set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff); 1948 1949 mutex_unlock(&codec->spdif_mutex); 1950 return change; 1951 } 1952 1953 #define snd_hda_spdif_out_switch_info snd_ctl_boolean_mono_info 1954 1955 static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol, 1956 struct snd_ctl_elem_value *ucontrol) 1957 { 1958 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1959 1960 ucontrol->value.integer.value[0] = codec->spdif_ctls & AC_DIG1_ENABLE; 1961 return 0; 1962 } 1963 1964 static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol, 1965 struct snd_ctl_elem_value *ucontrol) 1966 { 1967 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1968 hda_nid_t nid = kcontrol->private_value; 1969 unsigned short val; 1970 int change; 1971 1972 mutex_lock(&codec->spdif_mutex); 1973 val = codec->spdif_ctls & ~AC_DIG1_ENABLE; 1974 if (ucontrol->value.integer.value[0]) 1975 val |= AC_DIG1_ENABLE; 1976 change = codec->spdif_ctls != val; 1977 if (change) { 1978 codec->spdif_ctls = val; 1979 set_dig_out_convert(codec, nid, val & 0xff, -1); 1980 /* unmute amp switch (if any) */ 1981 if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) && 1982 (val & AC_DIG1_ENABLE)) 1983 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0, 1984 HDA_AMP_MUTE, 0); 1985 } 1986 mutex_unlock(&codec->spdif_mutex); 1987 return change; 1988 } 1989 1990 static struct snd_kcontrol_new dig_mixes[] = { 1991 { 1992 .access = SNDRV_CTL_ELEM_ACCESS_READ, 1993 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1994 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,CON_MASK), 1995 .info = snd_hda_spdif_mask_info, 1996 .get = snd_hda_spdif_cmask_get, 1997 }, 1998 { 1999 .access = SNDRV_CTL_ELEM_ACCESS_READ, 2000 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2001 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,PRO_MASK), 2002 .info = snd_hda_spdif_mask_info, 2003 .get = snd_hda_spdif_pmask_get, 2004 }, 2005 { 2006 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2007 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT), 2008 .info = snd_hda_spdif_mask_info, 2009 .get = snd_hda_spdif_default_get, 2010 .put = snd_hda_spdif_default_put, 2011 }, 2012 { 2013 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2014 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,SWITCH), 2015 .info = snd_hda_spdif_out_switch_info, 2016 .get = snd_hda_spdif_out_switch_get, 2017 .put = snd_hda_spdif_out_switch_put, 2018 }, 2019 { } /* end */ 2020 }; 2021 2022 #define SPDIF_MAX_IDX 4 /* 4 instances should be enough to probe */ 2023 2024 /** 2025 * snd_hda_create_spdif_out_ctls - create Output SPDIF-related controls 2026 * @codec: the HDA codec 2027 * @nid: audio out widget NID 2028 * 2029 * Creates controls related with the SPDIF output. 2030 * Called from each patch supporting the SPDIF out. 2031 * 2032 * Returns 0 if successful, or a negative error code. 2033 */ 2034 int snd_hda_create_spdif_out_ctls(struct hda_codec *codec, hda_nid_t nid) 2035 { 2036 int err; 2037 struct snd_kcontrol *kctl; 2038 struct snd_kcontrol_new *dig_mix; 2039 int idx; 2040 2041 for (idx = 0; idx < SPDIF_MAX_IDX; idx++) { 2042 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Playback Switch", 2043 idx)) 2044 break; 2045 } 2046 if (idx >= SPDIF_MAX_IDX) { 2047 printk(KERN_ERR "hda_codec: too many IEC958 outputs\n"); 2048 return -EBUSY; 2049 } 2050 for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) { 2051 kctl = snd_ctl_new1(dig_mix, codec); 2052 if (!kctl) 2053 return -ENOMEM; 2054 kctl->id.index = idx; 2055 kctl->private_value = nid; 2056 err = snd_hda_ctl_add(codec, kctl); 2057 if (err < 0) 2058 return err; 2059 } 2060 codec->spdif_ctls = 2061 snd_hda_codec_read(codec, nid, 0, 2062 AC_VERB_GET_DIGI_CONVERT_1, 0); 2063 codec->spdif_status = convert_to_spdif_status(codec->spdif_ctls); 2064 return 0; 2065 } 2066 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_out_ctls); 2067 2068 /* 2069 * SPDIF sharing with analog output 2070 */ 2071 static int spdif_share_sw_get(struct snd_kcontrol *kcontrol, 2072 struct snd_ctl_elem_value *ucontrol) 2073 { 2074 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol); 2075 ucontrol->value.integer.value[0] = mout->share_spdif; 2076 return 0; 2077 } 2078 2079 static int spdif_share_sw_put(struct snd_kcontrol *kcontrol, 2080 struct snd_ctl_elem_value *ucontrol) 2081 { 2082 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol); 2083 mout->share_spdif = !!ucontrol->value.integer.value[0]; 2084 return 0; 2085 } 2086 2087 static struct snd_kcontrol_new spdif_share_sw = { 2088 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2089 .name = "IEC958 Default PCM Playback Switch", 2090 .info = snd_ctl_boolean_mono_info, 2091 .get = spdif_share_sw_get, 2092 .put = spdif_share_sw_put, 2093 }; 2094 2095 int snd_hda_create_spdif_share_sw(struct hda_codec *codec, 2096 struct hda_multi_out *mout) 2097 { 2098 if (!mout->dig_out_nid) 2099 return 0; 2100 /* ATTENTION: here mout is passed as private_data, instead of codec */ 2101 return snd_hda_ctl_add(codec, 2102 snd_ctl_new1(&spdif_share_sw, mout)); 2103 } 2104 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_share_sw); 2105 2106 /* 2107 * SPDIF input 2108 */ 2109 2110 #define snd_hda_spdif_in_switch_info snd_hda_spdif_out_switch_info 2111 2112 static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol, 2113 struct snd_ctl_elem_value *ucontrol) 2114 { 2115 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2116 2117 ucontrol->value.integer.value[0] = codec->spdif_in_enable; 2118 return 0; 2119 } 2120 2121 static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol, 2122 struct snd_ctl_elem_value *ucontrol) 2123 { 2124 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2125 hda_nid_t nid = kcontrol->private_value; 2126 unsigned int val = !!ucontrol->value.integer.value[0]; 2127 int change; 2128 2129 mutex_lock(&codec->spdif_mutex); 2130 change = codec->spdif_in_enable != val; 2131 if (change) { 2132 codec->spdif_in_enable = val; 2133 snd_hda_codec_write_cache(codec, nid, 0, 2134 AC_VERB_SET_DIGI_CONVERT_1, val); 2135 } 2136 mutex_unlock(&codec->spdif_mutex); 2137 return change; 2138 } 2139 2140 static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol, 2141 struct snd_ctl_elem_value *ucontrol) 2142 { 2143 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2144 hda_nid_t nid = kcontrol->private_value; 2145 unsigned short val; 2146 unsigned int sbits; 2147 2148 val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DIGI_CONVERT_1, 0); 2149 sbits = convert_to_spdif_status(val); 2150 ucontrol->value.iec958.status[0] = sbits; 2151 ucontrol->value.iec958.status[1] = sbits >> 8; 2152 ucontrol->value.iec958.status[2] = sbits >> 16; 2153 ucontrol->value.iec958.status[3] = sbits >> 24; 2154 return 0; 2155 } 2156 2157 static struct snd_kcontrol_new dig_in_ctls[] = { 2158 { 2159 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2160 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,SWITCH), 2161 .info = snd_hda_spdif_in_switch_info, 2162 .get = snd_hda_spdif_in_switch_get, 2163 .put = snd_hda_spdif_in_switch_put, 2164 }, 2165 { 2166 .access = SNDRV_CTL_ELEM_ACCESS_READ, 2167 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2168 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,DEFAULT), 2169 .info = snd_hda_spdif_mask_info, 2170 .get = snd_hda_spdif_in_status_get, 2171 }, 2172 { } /* end */ 2173 }; 2174 2175 /** 2176 * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls 2177 * @codec: the HDA codec 2178 * @nid: audio in widget NID 2179 * 2180 * Creates controls related with the SPDIF input. 2181 * Called from each patch supporting the SPDIF in. 2182 * 2183 * Returns 0 if successful, or a negative error code. 2184 */ 2185 int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid) 2186 { 2187 int err; 2188 struct snd_kcontrol *kctl; 2189 struct snd_kcontrol_new *dig_mix; 2190 int idx; 2191 2192 for (idx = 0; idx < SPDIF_MAX_IDX; idx++) { 2193 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Capture Switch", 2194 idx)) 2195 break; 2196 } 2197 if (idx >= SPDIF_MAX_IDX) { 2198 printk(KERN_ERR "hda_codec: too many IEC958 inputs\n"); 2199 return -EBUSY; 2200 } 2201 for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) { 2202 kctl = snd_ctl_new1(dig_mix, codec); 2203 if (!kctl) 2204 return -ENOMEM; 2205 kctl->private_value = nid; 2206 err = snd_hda_ctl_add(codec, kctl); 2207 if (err < 0) 2208 return err; 2209 } 2210 codec->spdif_in_enable = 2211 snd_hda_codec_read(codec, nid, 0, 2212 AC_VERB_GET_DIGI_CONVERT_1, 0) & 2213 AC_DIG1_ENABLE; 2214 return 0; 2215 } 2216 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_in_ctls); 2217 2218 #ifdef SND_HDA_NEEDS_RESUME 2219 /* 2220 * command cache 2221 */ 2222 2223 /* build a 32bit cache key with the widget id and the command parameter */ 2224 #define build_cmd_cache_key(nid, verb) ((verb << 8) | nid) 2225 #define get_cmd_cache_nid(key) ((key) & 0xff) 2226 #define get_cmd_cache_cmd(key) (((key) >> 8) & 0xffff) 2227 2228 /** 2229 * snd_hda_codec_write_cache - send a single command with caching 2230 * @codec: the HDA codec 2231 * @nid: NID to send the command 2232 * @direct: direct flag 2233 * @verb: the verb to send 2234 * @parm: the parameter for the verb 2235 * 2236 * Send a single command without waiting for response. 2237 * 2238 * Returns 0 if successful, or a negative error code. 2239 */ 2240 int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid, 2241 int direct, unsigned int verb, unsigned int parm) 2242 { 2243 struct hda_bus *bus = codec->bus; 2244 unsigned int res; 2245 int err; 2246 2247 res = make_codec_cmd(codec, nid, direct, verb, parm); 2248 snd_hda_power_up(codec); 2249 mutex_lock(&bus->cmd_mutex); 2250 err = bus->ops.command(bus, res); 2251 if (!err) { 2252 struct hda_cache_head *c; 2253 u32 key; 2254 /* parm may contain the verb stuff for get/set amp */ 2255 verb = verb | (parm >> 8); 2256 parm &= 0xff; 2257 key = build_cmd_cache_key(nid, verb); 2258 c = get_alloc_hash(&codec->cmd_cache, key); 2259 if (c) 2260 c->val = parm; 2261 } 2262 mutex_unlock(&bus->cmd_mutex); 2263 snd_hda_power_down(codec); 2264 return err; 2265 } 2266 EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache); 2267 2268 /* resume the all commands from the cache */ 2269 void snd_hda_codec_resume_cache(struct hda_codec *codec) 2270 { 2271 struct hda_cache_head *buffer = codec->cmd_cache.buf.list; 2272 int i; 2273 2274 for (i = 0; i < codec->cmd_cache.buf.used; i++, buffer++) { 2275 u32 key = buffer->key; 2276 if (!key) 2277 continue; 2278 snd_hda_codec_write(codec, get_cmd_cache_nid(key), 0, 2279 get_cmd_cache_cmd(key), buffer->val); 2280 } 2281 } 2282 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_cache); 2283 2284 /** 2285 * snd_hda_sequence_write_cache - sequence writes with caching 2286 * @codec: the HDA codec 2287 * @seq: VERB array to send 2288 * 2289 * Send the commands sequentially from the given array. 2290 * Thte commands are recorded on cache for power-save and resume. 2291 * The array must be terminated with NID=0. 2292 */ 2293 void snd_hda_sequence_write_cache(struct hda_codec *codec, 2294 const struct hda_verb *seq) 2295 { 2296 for (; seq->nid; seq++) 2297 snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb, 2298 seq->param); 2299 } 2300 EXPORT_SYMBOL_HDA(snd_hda_sequence_write_cache); 2301 #endif /* SND_HDA_NEEDS_RESUME */ 2302 2303 /* 2304 * set power state of the codec 2305 */ 2306 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg, 2307 unsigned int power_state) 2308 { 2309 hda_nid_t nid; 2310 int i; 2311 2312 snd_hda_codec_write(codec, fg, 0, AC_VERB_SET_POWER_STATE, 2313 power_state); 2314 msleep(10); /* partial workaround for "azx_get_response timeout" */ 2315 2316 nid = codec->start_nid; 2317 for (i = 0; i < codec->num_nodes; i++, nid++) { 2318 unsigned int wcaps = get_wcaps(codec, nid); 2319 if (wcaps & AC_WCAP_POWER) { 2320 unsigned int wid_type = (wcaps & AC_WCAP_TYPE) >> 2321 AC_WCAP_TYPE_SHIFT; 2322 if (wid_type == AC_WID_PIN) { 2323 unsigned int pincap; 2324 /* 2325 * don't power down the widget if it controls 2326 * eapd and EAPD_BTLENABLE is set. 2327 */ 2328 pincap = snd_hda_query_pin_caps(codec, nid); 2329 if (pincap & AC_PINCAP_EAPD) { 2330 int eapd = snd_hda_codec_read(codec, 2331 nid, 0, 2332 AC_VERB_GET_EAPD_BTLENABLE, 0); 2333 eapd &= 0x02; 2334 if (power_state == AC_PWRST_D3 && eapd) 2335 continue; 2336 } 2337 } 2338 snd_hda_codec_write(codec, nid, 0, 2339 AC_VERB_SET_POWER_STATE, 2340 power_state); 2341 } 2342 } 2343 2344 if (power_state == AC_PWRST_D0) { 2345 unsigned long end_time; 2346 int state; 2347 msleep(10); 2348 /* wait until the codec reachs to D0 */ 2349 end_time = jiffies + msecs_to_jiffies(500); 2350 do { 2351 state = snd_hda_codec_read(codec, fg, 0, 2352 AC_VERB_GET_POWER_STATE, 0); 2353 if (state == power_state) 2354 break; 2355 msleep(1); 2356 } while (time_after_eq(end_time, jiffies)); 2357 } 2358 } 2359 2360 #ifdef CONFIG_SND_HDA_HWDEP 2361 /* execute additional init verbs */ 2362 static void hda_exec_init_verbs(struct hda_codec *codec) 2363 { 2364 if (codec->init_verbs.list) 2365 snd_hda_sequence_write(codec, codec->init_verbs.list); 2366 } 2367 #else 2368 static inline void hda_exec_init_verbs(struct hda_codec *codec) {} 2369 #endif 2370 2371 #ifdef SND_HDA_NEEDS_RESUME 2372 /* 2373 * call suspend and power-down; used both from PM and power-save 2374 */ 2375 static void hda_call_codec_suspend(struct hda_codec *codec) 2376 { 2377 if (codec->patch_ops.suspend) 2378 codec->patch_ops.suspend(codec, PMSG_SUSPEND); 2379 hda_set_power_state(codec, 2380 codec->afg ? codec->afg : codec->mfg, 2381 AC_PWRST_D3); 2382 #ifdef CONFIG_SND_HDA_POWER_SAVE 2383 cancel_delayed_work(&codec->power_work); 2384 codec->power_on = 0; 2385 codec->power_transition = 0; 2386 #endif 2387 } 2388 2389 /* 2390 * kick up codec; used both from PM and power-save 2391 */ 2392 static void hda_call_codec_resume(struct hda_codec *codec) 2393 { 2394 hda_set_power_state(codec, 2395 codec->afg ? codec->afg : codec->mfg, 2396 AC_PWRST_D0); 2397 restore_pincfgs(codec); /* restore all current pin configs */ 2398 hda_exec_init_verbs(codec); 2399 if (codec->patch_ops.resume) 2400 codec->patch_ops.resume(codec); 2401 else { 2402 if (codec->patch_ops.init) 2403 codec->patch_ops.init(codec); 2404 snd_hda_codec_resume_amp(codec); 2405 snd_hda_codec_resume_cache(codec); 2406 } 2407 } 2408 #endif /* SND_HDA_NEEDS_RESUME */ 2409 2410 2411 /** 2412 * snd_hda_build_controls - build mixer controls 2413 * @bus: the BUS 2414 * 2415 * Creates mixer controls for each codec included in the bus. 2416 * 2417 * Returns 0 if successful, otherwise a negative error code. 2418 */ 2419 int /*__devinit*/ snd_hda_build_controls(struct hda_bus *bus) 2420 { 2421 struct hda_codec *codec; 2422 2423 list_for_each_entry(codec, &bus->codec_list, list) { 2424 int err = snd_hda_codec_build_controls(codec); 2425 if (err < 0) { 2426 printk(KERN_ERR "hda_codec: cannot build controls" 2427 "for #%d (error %d)\n", codec->addr, err); 2428 err = snd_hda_codec_reset(codec); 2429 if (err < 0) { 2430 printk(KERN_ERR 2431 "hda_codec: cannot revert codec\n"); 2432 return err; 2433 } 2434 } 2435 } 2436 return 0; 2437 } 2438 EXPORT_SYMBOL_HDA(snd_hda_build_controls); 2439 2440 int snd_hda_codec_build_controls(struct hda_codec *codec) 2441 { 2442 int err = 0; 2443 hda_exec_init_verbs(codec); 2444 /* continue to initialize... */ 2445 if (codec->patch_ops.init) 2446 err = codec->patch_ops.init(codec); 2447 if (!err && codec->patch_ops.build_controls) 2448 err = codec->patch_ops.build_controls(codec); 2449 if (err < 0) 2450 return err; 2451 return 0; 2452 } 2453 2454 /* 2455 * stream formats 2456 */ 2457 struct hda_rate_tbl { 2458 unsigned int hz; 2459 unsigned int alsa_bits; 2460 unsigned int hda_fmt; 2461 }; 2462 2463 static struct hda_rate_tbl rate_bits[] = { 2464 /* rate in Hz, ALSA rate bitmask, HDA format value */ 2465 2466 /* autodetected value used in snd_hda_query_supported_pcm */ 2467 { 8000, SNDRV_PCM_RATE_8000, 0x0500 }, /* 1/6 x 48 */ 2468 { 11025, SNDRV_PCM_RATE_11025, 0x4300 }, /* 1/4 x 44 */ 2469 { 16000, SNDRV_PCM_RATE_16000, 0x0200 }, /* 1/3 x 48 */ 2470 { 22050, SNDRV_PCM_RATE_22050, 0x4100 }, /* 1/2 x 44 */ 2471 { 32000, SNDRV_PCM_RATE_32000, 0x0a00 }, /* 2/3 x 48 */ 2472 { 44100, SNDRV_PCM_RATE_44100, 0x4000 }, /* 44 */ 2473 { 48000, SNDRV_PCM_RATE_48000, 0x0000 }, /* 48 */ 2474 { 88200, SNDRV_PCM_RATE_88200, 0x4800 }, /* 2 x 44 */ 2475 { 96000, SNDRV_PCM_RATE_96000, 0x0800 }, /* 2 x 48 */ 2476 { 176400, SNDRV_PCM_RATE_176400, 0x5800 },/* 4 x 44 */ 2477 { 192000, SNDRV_PCM_RATE_192000, 0x1800 }, /* 4 x 48 */ 2478 #define AC_PAR_PCM_RATE_BITS 11 2479 /* up to bits 10, 384kHZ isn't supported properly */ 2480 2481 /* not autodetected value */ 2482 { 9600, SNDRV_PCM_RATE_KNOT, 0x0400 }, /* 1/5 x 48 */ 2483 2484 { 0 } /* terminator */ 2485 }; 2486 2487 /** 2488 * snd_hda_calc_stream_format - calculate format bitset 2489 * @rate: the sample rate 2490 * @channels: the number of channels 2491 * @format: the PCM format (SNDRV_PCM_FORMAT_XXX) 2492 * @maxbps: the max. bps 2493 * 2494 * Calculate the format bitset from the given rate, channels and th PCM format. 2495 * 2496 * Return zero if invalid. 2497 */ 2498 unsigned int snd_hda_calc_stream_format(unsigned int rate, 2499 unsigned int channels, 2500 unsigned int format, 2501 unsigned int maxbps) 2502 { 2503 int i; 2504 unsigned int val = 0; 2505 2506 for (i = 0; rate_bits[i].hz; i++) 2507 if (rate_bits[i].hz == rate) { 2508 val = rate_bits[i].hda_fmt; 2509 break; 2510 } 2511 if (!rate_bits[i].hz) { 2512 snd_printdd("invalid rate %d\n", rate); 2513 return 0; 2514 } 2515 2516 if (channels == 0 || channels > 8) { 2517 snd_printdd("invalid channels %d\n", channels); 2518 return 0; 2519 } 2520 val |= channels - 1; 2521 2522 switch (snd_pcm_format_width(format)) { 2523 case 8: val |= 0x00; break; 2524 case 16: val |= 0x10; break; 2525 case 20: 2526 case 24: 2527 case 32: 2528 if (maxbps >= 32) 2529 val |= 0x40; 2530 else if (maxbps >= 24) 2531 val |= 0x30; 2532 else 2533 val |= 0x20; 2534 break; 2535 default: 2536 snd_printdd("invalid format width %d\n", 2537 snd_pcm_format_width(format)); 2538 return 0; 2539 } 2540 2541 return val; 2542 } 2543 EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format); 2544 2545 /** 2546 * snd_hda_query_supported_pcm - query the supported PCM rates and formats 2547 * @codec: the HDA codec 2548 * @nid: NID to query 2549 * @ratesp: the pointer to store the detected rate bitflags 2550 * @formatsp: the pointer to store the detected formats 2551 * @bpsp: the pointer to store the detected format widths 2552 * 2553 * Queries the supported PCM rates and formats. The NULL @ratesp, @formatsp 2554 * or @bsps argument is ignored. 2555 * 2556 * Returns 0 if successful, otherwise a negative error code. 2557 */ 2558 static int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid, 2559 u32 *ratesp, u64 *formatsp, unsigned int *bpsp) 2560 { 2561 unsigned int i, val, wcaps; 2562 2563 val = 0; 2564 wcaps = get_wcaps(codec, nid); 2565 if (nid != codec->afg && (wcaps & AC_WCAP_FORMAT_OVRD)) { 2566 val = snd_hda_param_read(codec, nid, AC_PAR_PCM); 2567 if (val == -1) 2568 return -EIO; 2569 } 2570 if (!val) 2571 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM); 2572 2573 if (ratesp) { 2574 u32 rates = 0; 2575 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) { 2576 if (val & (1 << i)) 2577 rates |= rate_bits[i].alsa_bits; 2578 } 2579 if (rates == 0) { 2580 snd_printk(KERN_ERR "hda_codec: rates == 0 " 2581 "(nid=0x%x, val=0x%x, ovrd=%i)\n", 2582 nid, val, 2583 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0); 2584 return -EIO; 2585 } 2586 *ratesp = rates; 2587 } 2588 2589 if (formatsp || bpsp) { 2590 u64 formats = 0; 2591 unsigned int streams, bps; 2592 2593 streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM); 2594 if (streams == -1) 2595 return -EIO; 2596 if (!streams) { 2597 streams = snd_hda_param_read(codec, codec->afg, 2598 AC_PAR_STREAM); 2599 if (streams == -1) 2600 return -EIO; 2601 } 2602 2603 bps = 0; 2604 if (streams & AC_SUPFMT_PCM) { 2605 if (val & AC_SUPPCM_BITS_8) { 2606 formats |= SNDRV_PCM_FMTBIT_U8; 2607 bps = 8; 2608 } 2609 if (val & AC_SUPPCM_BITS_16) { 2610 formats |= SNDRV_PCM_FMTBIT_S16_LE; 2611 bps = 16; 2612 } 2613 if (wcaps & AC_WCAP_DIGITAL) { 2614 if (val & AC_SUPPCM_BITS_32) 2615 formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE; 2616 if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24)) 2617 formats |= SNDRV_PCM_FMTBIT_S32_LE; 2618 if (val & AC_SUPPCM_BITS_24) 2619 bps = 24; 2620 else if (val & AC_SUPPCM_BITS_20) 2621 bps = 20; 2622 } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24| 2623 AC_SUPPCM_BITS_32)) { 2624 formats |= SNDRV_PCM_FMTBIT_S32_LE; 2625 if (val & AC_SUPPCM_BITS_32) 2626 bps = 32; 2627 else if (val & AC_SUPPCM_BITS_24) 2628 bps = 24; 2629 else if (val & AC_SUPPCM_BITS_20) 2630 bps = 20; 2631 } 2632 } 2633 else if (streams == AC_SUPFMT_FLOAT32) { 2634 /* should be exclusive */ 2635 formats |= SNDRV_PCM_FMTBIT_FLOAT_LE; 2636 bps = 32; 2637 } else if (streams == AC_SUPFMT_AC3) { 2638 /* should be exclusive */ 2639 /* temporary hack: we have still no proper support 2640 * for the direct AC3 stream... 2641 */ 2642 formats |= SNDRV_PCM_FMTBIT_U8; 2643 bps = 8; 2644 } 2645 if (formats == 0) { 2646 snd_printk(KERN_ERR "hda_codec: formats == 0 " 2647 "(nid=0x%x, val=0x%x, ovrd=%i, " 2648 "streams=0x%x)\n", 2649 nid, val, 2650 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0, 2651 streams); 2652 return -EIO; 2653 } 2654 if (formatsp) 2655 *formatsp = formats; 2656 if (bpsp) 2657 *bpsp = bps; 2658 } 2659 2660 return 0; 2661 } 2662 2663 /** 2664 * snd_hda_is_supported_format - check whether the given node supports 2665 * the format val 2666 * 2667 * Returns 1 if supported, 0 if not. 2668 */ 2669 int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid, 2670 unsigned int format) 2671 { 2672 int i; 2673 unsigned int val = 0, rate, stream; 2674 2675 if (nid != codec->afg && 2676 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD)) { 2677 val = snd_hda_param_read(codec, nid, AC_PAR_PCM); 2678 if (val == -1) 2679 return 0; 2680 } 2681 if (!val) { 2682 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM); 2683 if (val == -1) 2684 return 0; 2685 } 2686 2687 rate = format & 0xff00; 2688 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) 2689 if (rate_bits[i].hda_fmt == rate) { 2690 if (val & (1 << i)) 2691 break; 2692 return 0; 2693 } 2694 if (i >= AC_PAR_PCM_RATE_BITS) 2695 return 0; 2696 2697 stream = snd_hda_param_read(codec, nid, AC_PAR_STREAM); 2698 if (stream == -1) 2699 return 0; 2700 if (!stream && nid != codec->afg) 2701 stream = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM); 2702 if (!stream || stream == -1) 2703 return 0; 2704 2705 if (stream & AC_SUPFMT_PCM) { 2706 switch (format & 0xf0) { 2707 case 0x00: 2708 if (!(val & AC_SUPPCM_BITS_8)) 2709 return 0; 2710 break; 2711 case 0x10: 2712 if (!(val & AC_SUPPCM_BITS_16)) 2713 return 0; 2714 break; 2715 case 0x20: 2716 if (!(val & AC_SUPPCM_BITS_20)) 2717 return 0; 2718 break; 2719 case 0x30: 2720 if (!(val & AC_SUPPCM_BITS_24)) 2721 return 0; 2722 break; 2723 case 0x40: 2724 if (!(val & AC_SUPPCM_BITS_32)) 2725 return 0; 2726 break; 2727 default: 2728 return 0; 2729 } 2730 } else { 2731 /* FIXME: check for float32 and AC3? */ 2732 } 2733 2734 return 1; 2735 } 2736 EXPORT_SYMBOL_HDA(snd_hda_is_supported_format); 2737 2738 /* 2739 * PCM stuff 2740 */ 2741 static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo, 2742 struct hda_codec *codec, 2743 struct snd_pcm_substream *substream) 2744 { 2745 return 0; 2746 } 2747 2748 static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo, 2749 struct hda_codec *codec, 2750 unsigned int stream_tag, 2751 unsigned int format, 2752 struct snd_pcm_substream *substream) 2753 { 2754 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format); 2755 return 0; 2756 } 2757 2758 static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo, 2759 struct hda_codec *codec, 2760 struct snd_pcm_substream *substream) 2761 { 2762 snd_hda_codec_cleanup_stream(codec, hinfo->nid); 2763 return 0; 2764 } 2765 2766 static int set_pcm_default_values(struct hda_codec *codec, 2767 struct hda_pcm_stream *info) 2768 { 2769 int err; 2770 2771 /* query support PCM information from the given NID */ 2772 if (info->nid && (!info->rates || !info->formats)) { 2773 err = snd_hda_query_supported_pcm(codec, info->nid, 2774 info->rates ? NULL : &info->rates, 2775 info->formats ? NULL : &info->formats, 2776 info->maxbps ? NULL : &info->maxbps); 2777 if (err < 0) 2778 return err; 2779 } 2780 if (info->ops.open == NULL) 2781 info->ops.open = hda_pcm_default_open_close; 2782 if (info->ops.close == NULL) 2783 info->ops.close = hda_pcm_default_open_close; 2784 if (info->ops.prepare == NULL) { 2785 if (snd_BUG_ON(!info->nid)) 2786 return -EINVAL; 2787 info->ops.prepare = hda_pcm_default_prepare; 2788 } 2789 if (info->ops.cleanup == NULL) { 2790 if (snd_BUG_ON(!info->nid)) 2791 return -EINVAL; 2792 info->ops.cleanup = hda_pcm_default_cleanup; 2793 } 2794 return 0; 2795 } 2796 2797 /* 2798 * get the empty PCM device number to assign 2799 */ 2800 static int get_empty_pcm_device(struct hda_bus *bus, int type) 2801 { 2802 static const char *dev_name[HDA_PCM_NTYPES] = { 2803 "Audio", "SPDIF", "HDMI", "Modem" 2804 }; 2805 /* starting device index for each PCM type */ 2806 static int dev_idx[HDA_PCM_NTYPES] = { 2807 [HDA_PCM_TYPE_AUDIO] = 0, 2808 [HDA_PCM_TYPE_SPDIF] = 1, 2809 [HDA_PCM_TYPE_HDMI] = 3, 2810 [HDA_PCM_TYPE_MODEM] = 6 2811 }; 2812 /* normal audio device indices; not linear to keep compatibility */ 2813 static int audio_idx[4] = { 0, 2, 4, 5 }; 2814 int i, dev; 2815 2816 switch (type) { 2817 case HDA_PCM_TYPE_AUDIO: 2818 for (i = 0; i < ARRAY_SIZE(audio_idx); i++) { 2819 dev = audio_idx[i]; 2820 if (!test_bit(dev, bus->pcm_dev_bits)) 2821 goto ok; 2822 } 2823 snd_printk(KERN_WARNING "Too many audio devices\n"); 2824 return -EAGAIN; 2825 case HDA_PCM_TYPE_SPDIF: 2826 case HDA_PCM_TYPE_HDMI: 2827 case HDA_PCM_TYPE_MODEM: 2828 dev = dev_idx[type]; 2829 if (test_bit(dev, bus->pcm_dev_bits)) { 2830 snd_printk(KERN_WARNING "%s already defined\n", 2831 dev_name[type]); 2832 return -EAGAIN; 2833 } 2834 break; 2835 default: 2836 snd_printk(KERN_WARNING "Invalid PCM type %d\n", type); 2837 return -EINVAL; 2838 } 2839 ok: 2840 set_bit(dev, bus->pcm_dev_bits); 2841 return dev; 2842 } 2843 2844 /* 2845 * attach a new PCM stream 2846 */ 2847 static int snd_hda_attach_pcm(struct hda_codec *codec, struct hda_pcm *pcm) 2848 { 2849 struct hda_bus *bus = codec->bus; 2850 struct hda_pcm_stream *info; 2851 int stream, err; 2852 2853 if (snd_BUG_ON(!pcm->name)) 2854 return -EINVAL; 2855 for (stream = 0; stream < 2; stream++) { 2856 info = &pcm->stream[stream]; 2857 if (info->substreams) { 2858 err = set_pcm_default_values(codec, info); 2859 if (err < 0) 2860 return err; 2861 } 2862 } 2863 return bus->ops.attach_pcm(bus, codec, pcm); 2864 } 2865 2866 /* assign all PCMs of the given codec */ 2867 int snd_hda_codec_build_pcms(struct hda_codec *codec) 2868 { 2869 unsigned int pcm; 2870 int err; 2871 2872 if (!codec->num_pcms) { 2873 if (!codec->patch_ops.build_pcms) 2874 return 0; 2875 err = codec->patch_ops.build_pcms(codec); 2876 if (err < 0) { 2877 printk(KERN_ERR "hda_codec: cannot build PCMs" 2878 "for #%d (error %d)\n", codec->addr, err); 2879 err = snd_hda_codec_reset(codec); 2880 if (err < 0) { 2881 printk(KERN_ERR 2882 "hda_codec: cannot revert codec\n"); 2883 return err; 2884 } 2885 } 2886 } 2887 for (pcm = 0; pcm < codec->num_pcms; pcm++) { 2888 struct hda_pcm *cpcm = &codec->pcm_info[pcm]; 2889 int dev; 2890 2891 if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams) 2892 continue; /* no substreams assigned */ 2893 2894 if (!cpcm->pcm) { 2895 dev = get_empty_pcm_device(codec->bus, cpcm->pcm_type); 2896 if (dev < 0) 2897 continue; /* no fatal error */ 2898 cpcm->device = dev; 2899 err = snd_hda_attach_pcm(codec, cpcm); 2900 if (err < 0) { 2901 printk(KERN_ERR "hda_codec: cannot attach " 2902 "PCM stream %d for codec #%d\n", 2903 dev, codec->addr); 2904 continue; /* no fatal error */ 2905 } 2906 } 2907 } 2908 return 0; 2909 } 2910 2911 /** 2912 * snd_hda_build_pcms - build PCM information 2913 * @bus: the BUS 2914 * 2915 * Create PCM information for each codec included in the bus. 2916 * 2917 * The build_pcms codec patch is requested to set up codec->num_pcms and 2918 * codec->pcm_info properly. The array is referred by the top-level driver 2919 * to create its PCM instances. 2920 * The allocated codec->pcm_info should be released in codec->patch_ops.free 2921 * callback. 2922 * 2923 * At least, substreams, channels_min and channels_max must be filled for 2924 * each stream. substreams = 0 indicates that the stream doesn't exist. 2925 * When rates and/or formats are zero, the supported values are queried 2926 * from the given nid. The nid is used also by the default ops.prepare 2927 * and ops.cleanup callbacks. 2928 * 2929 * The driver needs to call ops.open in its open callback. Similarly, 2930 * ops.close is supposed to be called in the close callback. 2931 * ops.prepare should be called in the prepare or hw_params callback 2932 * with the proper parameters for set up. 2933 * ops.cleanup should be called in hw_free for clean up of streams. 2934 * 2935 * This function returns 0 if successfull, or a negative error code. 2936 */ 2937 int __devinit snd_hda_build_pcms(struct hda_bus *bus) 2938 { 2939 struct hda_codec *codec; 2940 2941 list_for_each_entry(codec, &bus->codec_list, list) { 2942 int err = snd_hda_codec_build_pcms(codec); 2943 if (err < 0) 2944 return err; 2945 } 2946 return 0; 2947 } 2948 EXPORT_SYMBOL_HDA(snd_hda_build_pcms); 2949 2950 /** 2951 * snd_hda_check_board_config - compare the current codec with the config table 2952 * @codec: the HDA codec 2953 * @num_configs: number of config enums 2954 * @models: array of model name strings 2955 * @tbl: configuration table, terminated by null entries 2956 * 2957 * Compares the modelname or PCI subsystem id of the current codec with the 2958 * given configuration table. If a matching entry is found, returns its 2959 * config value (supposed to be 0 or positive). 2960 * 2961 * If no entries are matching, the function returns a negative value. 2962 */ 2963 int snd_hda_check_board_config(struct hda_codec *codec, 2964 int num_configs, const char **models, 2965 const struct snd_pci_quirk *tbl) 2966 { 2967 if (codec->modelname && models) { 2968 int i; 2969 for (i = 0; i < num_configs; i++) { 2970 if (models[i] && 2971 !strcmp(codec->modelname, models[i])) { 2972 snd_printd(KERN_INFO "hda_codec: model '%s' is " 2973 "selected\n", models[i]); 2974 return i; 2975 } 2976 } 2977 } 2978 2979 if (!codec->bus->pci || !tbl) 2980 return -1; 2981 2982 tbl = snd_pci_quirk_lookup(codec->bus->pci, tbl); 2983 if (!tbl) 2984 return -1; 2985 if (tbl->value >= 0 && tbl->value < num_configs) { 2986 #ifdef CONFIG_SND_DEBUG_VERBOSE 2987 char tmp[10]; 2988 const char *model = NULL; 2989 if (models) 2990 model = models[tbl->value]; 2991 if (!model) { 2992 sprintf(tmp, "#%d", tbl->value); 2993 model = tmp; 2994 } 2995 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected " 2996 "for config %x:%x (%s)\n", 2997 model, tbl->subvendor, tbl->subdevice, 2998 (tbl->name ? tbl->name : "Unknown device")); 2999 #endif 3000 return tbl->value; 3001 } 3002 return -1; 3003 } 3004 EXPORT_SYMBOL_HDA(snd_hda_check_board_config); 3005 3006 /** 3007 * snd_hda_check_board_codec_sid_config - compare the current codec 3008 subsystem ID with the 3009 config table 3010 3011 This is important for Gateway notebooks with SB450 HDA Audio 3012 where the vendor ID of the PCI device is: 3013 ATI Technologies Inc SB450 HDA Audio [1002:437b] 3014 and the vendor/subvendor are found only at the codec. 3015 3016 * @codec: the HDA codec 3017 * @num_configs: number of config enums 3018 * @models: array of model name strings 3019 * @tbl: configuration table, terminated by null entries 3020 * 3021 * Compares the modelname or PCI subsystem id of the current codec with the 3022 * given configuration table. If a matching entry is found, returns its 3023 * config value (supposed to be 0 or positive). 3024 * 3025 * If no entries are matching, the function returns a negative value. 3026 */ 3027 int snd_hda_check_board_codec_sid_config(struct hda_codec *codec, 3028 int num_configs, const char **models, 3029 const struct snd_pci_quirk *tbl) 3030 { 3031 const struct snd_pci_quirk *q; 3032 3033 /* Search for codec ID */ 3034 for (q = tbl; q->subvendor; q++) { 3035 unsigned long vendorid = (q->subdevice) | (q->subvendor << 16); 3036 3037 if (vendorid == codec->subsystem_id) 3038 break; 3039 } 3040 3041 if (!q->subvendor) 3042 return -1; 3043 3044 tbl = q; 3045 3046 if (tbl->value >= 0 && tbl->value < num_configs) { 3047 #ifdef CONFIG_SND_DEBUG_DETECT 3048 char tmp[10]; 3049 const char *model = NULL; 3050 if (models) 3051 model = models[tbl->value]; 3052 if (!model) { 3053 sprintf(tmp, "#%d", tbl->value); 3054 model = tmp; 3055 } 3056 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected " 3057 "for config %x:%x (%s)\n", 3058 model, tbl->subvendor, tbl->subdevice, 3059 (tbl->name ? tbl->name : "Unknown device")); 3060 #endif 3061 return tbl->value; 3062 } 3063 return -1; 3064 } 3065 EXPORT_SYMBOL_HDA(snd_hda_check_board_codec_sid_config); 3066 3067 /** 3068 * snd_hda_add_new_ctls - create controls from the array 3069 * @codec: the HDA codec 3070 * @knew: the array of struct snd_kcontrol_new 3071 * 3072 * This helper function creates and add new controls in the given array. 3073 * The array must be terminated with an empty entry as terminator. 3074 * 3075 * Returns 0 if successful, or a negative error code. 3076 */ 3077 int snd_hda_add_new_ctls(struct hda_codec *codec, struct snd_kcontrol_new *knew) 3078 { 3079 int err; 3080 3081 for (; knew->name; knew++) { 3082 struct snd_kcontrol *kctl; 3083 kctl = snd_ctl_new1(knew, codec); 3084 if (!kctl) 3085 return -ENOMEM; 3086 err = snd_hda_ctl_add(codec, kctl); 3087 if (err < 0) { 3088 if (!codec->addr) 3089 return err; 3090 kctl = snd_ctl_new1(knew, codec); 3091 if (!kctl) 3092 return -ENOMEM; 3093 kctl->id.device = codec->addr; 3094 err = snd_hda_ctl_add(codec, kctl); 3095 if (err < 0) 3096 return err; 3097 } 3098 } 3099 return 0; 3100 } 3101 EXPORT_SYMBOL_HDA(snd_hda_add_new_ctls); 3102 3103 #ifdef CONFIG_SND_HDA_POWER_SAVE 3104 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg, 3105 unsigned int power_state); 3106 3107 static void hda_power_work(struct work_struct *work) 3108 { 3109 struct hda_codec *codec = 3110 container_of(work, struct hda_codec, power_work.work); 3111 struct hda_bus *bus = codec->bus; 3112 3113 if (!codec->power_on || codec->power_count) { 3114 codec->power_transition = 0; 3115 return; 3116 } 3117 3118 hda_call_codec_suspend(codec); 3119 if (bus->ops.pm_notify) 3120 bus->ops.pm_notify(bus); 3121 } 3122 3123 static void hda_keep_power_on(struct hda_codec *codec) 3124 { 3125 codec->power_count++; 3126 codec->power_on = 1; 3127 } 3128 3129 void snd_hda_power_up(struct hda_codec *codec) 3130 { 3131 struct hda_bus *bus = codec->bus; 3132 3133 codec->power_count++; 3134 if (codec->power_on || codec->power_transition) 3135 return; 3136 3137 codec->power_on = 1; 3138 if (bus->ops.pm_notify) 3139 bus->ops.pm_notify(bus); 3140 hda_call_codec_resume(codec); 3141 cancel_delayed_work(&codec->power_work); 3142 codec->power_transition = 0; 3143 } 3144 EXPORT_SYMBOL_HDA(snd_hda_power_up); 3145 3146 #define power_save(codec) \ 3147 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0) 3148 3149 #define power_save(codec) \ 3150 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0) 3151 3152 void snd_hda_power_down(struct hda_codec *codec) 3153 { 3154 --codec->power_count; 3155 if (!codec->power_on || codec->power_count || codec->power_transition) 3156 return; 3157 if (power_save(codec)) { 3158 codec->power_transition = 1; /* avoid reentrance */ 3159 queue_delayed_work(codec->bus->workq, &codec->power_work, 3160 msecs_to_jiffies(power_save(codec) * 1000)); 3161 } 3162 } 3163 EXPORT_SYMBOL_HDA(snd_hda_power_down); 3164 3165 int snd_hda_check_amp_list_power(struct hda_codec *codec, 3166 struct hda_loopback_check *check, 3167 hda_nid_t nid) 3168 { 3169 struct hda_amp_list *p; 3170 int ch, v; 3171 3172 if (!check->amplist) 3173 return 0; 3174 for (p = check->amplist; p->nid; p++) { 3175 if (p->nid == nid) 3176 break; 3177 } 3178 if (!p->nid) 3179 return 0; /* nothing changed */ 3180 3181 for (p = check->amplist; p->nid; p++) { 3182 for (ch = 0; ch < 2; ch++) { 3183 v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir, 3184 p->idx); 3185 if (!(v & HDA_AMP_MUTE) && v > 0) { 3186 if (!check->power_on) { 3187 check->power_on = 1; 3188 snd_hda_power_up(codec); 3189 } 3190 return 1; 3191 } 3192 } 3193 } 3194 if (check->power_on) { 3195 check->power_on = 0; 3196 snd_hda_power_down(codec); 3197 } 3198 return 0; 3199 } 3200 EXPORT_SYMBOL_HDA(snd_hda_check_amp_list_power); 3201 #endif 3202 3203 /* 3204 * Channel mode helper 3205 */ 3206 int snd_hda_ch_mode_info(struct hda_codec *codec, 3207 struct snd_ctl_elem_info *uinfo, 3208 const struct hda_channel_mode *chmode, 3209 int num_chmodes) 3210 { 3211 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 3212 uinfo->count = 1; 3213 uinfo->value.enumerated.items = num_chmodes; 3214 if (uinfo->value.enumerated.item >= num_chmodes) 3215 uinfo->value.enumerated.item = num_chmodes - 1; 3216 sprintf(uinfo->value.enumerated.name, "%dch", 3217 chmode[uinfo->value.enumerated.item].channels); 3218 return 0; 3219 } 3220 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info); 3221 3222 int snd_hda_ch_mode_get(struct hda_codec *codec, 3223 struct snd_ctl_elem_value *ucontrol, 3224 const struct hda_channel_mode *chmode, 3225 int num_chmodes, 3226 int max_channels) 3227 { 3228 int i; 3229 3230 for (i = 0; i < num_chmodes; i++) { 3231 if (max_channels == chmode[i].channels) { 3232 ucontrol->value.enumerated.item[0] = i; 3233 break; 3234 } 3235 } 3236 return 0; 3237 } 3238 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get); 3239 3240 int snd_hda_ch_mode_put(struct hda_codec *codec, 3241 struct snd_ctl_elem_value *ucontrol, 3242 const struct hda_channel_mode *chmode, 3243 int num_chmodes, 3244 int *max_channelsp) 3245 { 3246 unsigned int mode; 3247 3248 mode = ucontrol->value.enumerated.item[0]; 3249 if (mode >= num_chmodes) 3250 return -EINVAL; 3251 if (*max_channelsp == chmode[mode].channels) 3252 return 0; 3253 /* change the current channel setting */ 3254 *max_channelsp = chmode[mode].channels; 3255 if (chmode[mode].sequence) 3256 snd_hda_sequence_write_cache(codec, chmode[mode].sequence); 3257 return 1; 3258 } 3259 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_put); 3260 3261 /* 3262 * input MUX helper 3263 */ 3264 int snd_hda_input_mux_info(const struct hda_input_mux *imux, 3265 struct snd_ctl_elem_info *uinfo) 3266 { 3267 unsigned int index; 3268 3269 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 3270 uinfo->count = 1; 3271 uinfo->value.enumerated.items = imux->num_items; 3272 if (!imux->num_items) 3273 return 0; 3274 index = uinfo->value.enumerated.item; 3275 if (index >= imux->num_items) 3276 index = imux->num_items - 1; 3277 strcpy(uinfo->value.enumerated.name, imux->items[index].label); 3278 return 0; 3279 } 3280 EXPORT_SYMBOL_HDA(snd_hda_input_mux_info); 3281 3282 int snd_hda_input_mux_put(struct hda_codec *codec, 3283 const struct hda_input_mux *imux, 3284 struct snd_ctl_elem_value *ucontrol, 3285 hda_nid_t nid, 3286 unsigned int *cur_val) 3287 { 3288 unsigned int idx; 3289 3290 if (!imux->num_items) 3291 return 0; 3292 idx = ucontrol->value.enumerated.item[0]; 3293 if (idx >= imux->num_items) 3294 idx = imux->num_items - 1; 3295 if (*cur_val == idx) 3296 return 0; 3297 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, 3298 imux->items[idx].index); 3299 *cur_val = idx; 3300 return 1; 3301 } 3302 EXPORT_SYMBOL_HDA(snd_hda_input_mux_put); 3303 3304 3305 /* 3306 * Multi-channel / digital-out PCM helper functions 3307 */ 3308 3309 /* setup SPDIF output stream */ 3310 static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid, 3311 unsigned int stream_tag, unsigned int format) 3312 { 3313 /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */ 3314 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE)) 3315 set_dig_out_convert(codec, nid, 3316 codec->spdif_ctls & ~AC_DIG1_ENABLE & 0xff, 3317 -1); 3318 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format); 3319 if (codec->slave_dig_outs) { 3320 hda_nid_t *d; 3321 for (d = codec->slave_dig_outs; *d; d++) 3322 snd_hda_codec_setup_stream(codec, *d, stream_tag, 0, 3323 format); 3324 } 3325 /* turn on again (if needed) */ 3326 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE)) 3327 set_dig_out_convert(codec, nid, 3328 codec->spdif_ctls & 0xff, -1); 3329 } 3330 3331 static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid) 3332 { 3333 snd_hda_codec_cleanup_stream(codec, nid); 3334 if (codec->slave_dig_outs) { 3335 hda_nid_t *d; 3336 for (d = codec->slave_dig_outs; *d; d++) 3337 snd_hda_codec_cleanup_stream(codec, *d); 3338 } 3339 } 3340 3341 /* 3342 * open the digital out in the exclusive mode 3343 */ 3344 int snd_hda_multi_out_dig_open(struct hda_codec *codec, 3345 struct hda_multi_out *mout) 3346 { 3347 mutex_lock(&codec->spdif_mutex); 3348 if (mout->dig_out_used == HDA_DIG_ANALOG_DUP) 3349 /* already opened as analog dup; reset it once */ 3350 cleanup_dig_out_stream(codec, mout->dig_out_nid); 3351 mout->dig_out_used = HDA_DIG_EXCLUSIVE; 3352 mutex_unlock(&codec->spdif_mutex); 3353 return 0; 3354 } 3355 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_open); 3356 3357 int snd_hda_multi_out_dig_prepare(struct hda_codec *codec, 3358 struct hda_multi_out *mout, 3359 unsigned int stream_tag, 3360 unsigned int format, 3361 struct snd_pcm_substream *substream) 3362 { 3363 mutex_lock(&codec->spdif_mutex); 3364 setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format); 3365 mutex_unlock(&codec->spdif_mutex); 3366 return 0; 3367 } 3368 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare); 3369 3370 int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec, 3371 struct hda_multi_out *mout) 3372 { 3373 mutex_lock(&codec->spdif_mutex); 3374 cleanup_dig_out_stream(codec, mout->dig_out_nid); 3375 mutex_unlock(&codec->spdif_mutex); 3376 return 0; 3377 } 3378 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_cleanup); 3379 3380 /* 3381 * release the digital out 3382 */ 3383 int snd_hda_multi_out_dig_close(struct hda_codec *codec, 3384 struct hda_multi_out *mout) 3385 { 3386 mutex_lock(&codec->spdif_mutex); 3387 mout->dig_out_used = 0; 3388 mutex_unlock(&codec->spdif_mutex); 3389 return 0; 3390 } 3391 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_close); 3392 3393 /* 3394 * set up more restrictions for analog out 3395 */ 3396 int snd_hda_multi_out_analog_open(struct hda_codec *codec, 3397 struct hda_multi_out *mout, 3398 struct snd_pcm_substream *substream, 3399 struct hda_pcm_stream *hinfo) 3400 { 3401 struct snd_pcm_runtime *runtime = substream->runtime; 3402 runtime->hw.channels_max = mout->max_channels; 3403 if (mout->dig_out_nid) { 3404 if (!mout->analog_rates) { 3405 mout->analog_rates = hinfo->rates; 3406 mout->analog_formats = hinfo->formats; 3407 mout->analog_maxbps = hinfo->maxbps; 3408 } else { 3409 runtime->hw.rates = mout->analog_rates; 3410 runtime->hw.formats = mout->analog_formats; 3411 hinfo->maxbps = mout->analog_maxbps; 3412 } 3413 if (!mout->spdif_rates) { 3414 snd_hda_query_supported_pcm(codec, mout->dig_out_nid, 3415 &mout->spdif_rates, 3416 &mout->spdif_formats, 3417 &mout->spdif_maxbps); 3418 } 3419 mutex_lock(&codec->spdif_mutex); 3420 if (mout->share_spdif) { 3421 runtime->hw.rates &= mout->spdif_rates; 3422 runtime->hw.formats &= mout->spdif_formats; 3423 if (mout->spdif_maxbps < hinfo->maxbps) 3424 hinfo->maxbps = mout->spdif_maxbps; 3425 } 3426 mutex_unlock(&codec->spdif_mutex); 3427 } 3428 return snd_pcm_hw_constraint_step(substream->runtime, 0, 3429 SNDRV_PCM_HW_PARAM_CHANNELS, 2); 3430 } 3431 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_open); 3432 3433 /* 3434 * set up the i/o for analog out 3435 * when the digital out is available, copy the front out to digital out, too. 3436 */ 3437 int snd_hda_multi_out_analog_prepare(struct hda_codec *codec, 3438 struct hda_multi_out *mout, 3439 unsigned int stream_tag, 3440 unsigned int format, 3441 struct snd_pcm_substream *substream) 3442 { 3443 hda_nid_t *nids = mout->dac_nids; 3444 int chs = substream->runtime->channels; 3445 int i; 3446 3447 mutex_lock(&codec->spdif_mutex); 3448 if (mout->dig_out_nid && mout->share_spdif && 3449 mout->dig_out_used != HDA_DIG_EXCLUSIVE) { 3450 if (chs == 2 && 3451 snd_hda_is_supported_format(codec, mout->dig_out_nid, 3452 format) && 3453 !(codec->spdif_status & IEC958_AES0_NONAUDIO)) { 3454 mout->dig_out_used = HDA_DIG_ANALOG_DUP; 3455 setup_dig_out_stream(codec, mout->dig_out_nid, 3456 stream_tag, format); 3457 } else { 3458 mout->dig_out_used = 0; 3459 cleanup_dig_out_stream(codec, mout->dig_out_nid); 3460 } 3461 } 3462 mutex_unlock(&codec->spdif_mutex); 3463 3464 /* front */ 3465 snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag, 3466 0, format); 3467 if (!mout->no_share_stream && 3468 mout->hp_nid && mout->hp_nid != nids[HDA_FRONT]) 3469 /* headphone out will just decode front left/right (stereo) */ 3470 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag, 3471 0, format); 3472 /* extra outputs copied from front */ 3473 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++) 3474 if (!mout->no_share_stream && mout->extra_out_nid[i]) 3475 snd_hda_codec_setup_stream(codec, 3476 mout->extra_out_nid[i], 3477 stream_tag, 0, format); 3478 3479 /* surrounds */ 3480 for (i = 1; i < mout->num_dacs; i++) { 3481 if (chs >= (i + 1) * 2) /* independent out */ 3482 snd_hda_codec_setup_stream(codec, nids[i], stream_tag, 3483 i * 2, format); 3484 else if (!mout->no_share_stream) /* copy front */ 3485 snd_hda_codec_setup_stream(codec, nids[i], stream_tag, 3486 0, format); 3487 } 3488 return 0; 3489 } 3490 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_prepare); 3491 3492 /* 3493 * clean up the setting for analog out 3494 */ 3495 int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec, 3496 struct hda_multi_out *mout) 3497 { 3498 hda_nid_t *nids = mout->dac_nids; 3499 int i; 3500 3501 for (i = 0; i < mout->num_dacs; i++) 3502 snd_hda_codec_cleanup_stream(codec, nids[i]); 3503 if (mout->hp_nid) 3504 snd_hda_codec_cleanup_stream(codec, mout->hp_nid); 3505 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++) 3506 if (mout->extra_out_nid[i]) 3507 snd_hda_codec_cleanup_stream(codec, 3508 mout->extra_out_nid[i]); 3509 mutex_lock(&codec->spdif_mutex); 3510 if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) { 3511 cleanup_dig_out_stream(codec, mout->dig_out_nid); 3512 mout->dig_out_used = 0; 3513 } 3514 mutex_unlock(&codec->spdif_mutex); 3515 return 0; 3516 } 3517 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_cleanup); 3518 3519 /* 3520 * Helper for automatic pin configuration 3521 */ 3522 3523 static int is_in_nid_list(hda_nid_t nid, hda_nid_t *list) 3524 { 3525 for (; *list; list++) 3526 if (*list == nid) 3527 return 1; 3528 return 0; 3529 } 3530 3531 3532 /* 3533 * Sort an associated group of pins according to their sequence numbers. 3534 */ 3535 static void sort_pins_by_sequence(hda_nid_t * pins, short * sequences, 3536 int num_pins) 3537 { 3538 int i, j; 3539 short seq; 3540 hda_nid_t nid; 3541 3542 for (i = 0; i < num_pins; i++) { 3543 for (j = i + 1; j < num_pins; j++) { 3544 if (sequences[i] > sequences[j]) { 3545 seq = sequences[i]; 3546 sequences[i] = sequences[j]; 3547 sequences[j] = seq; 3548 nid = pins[i]; 3549 pins[i] = pins[j]; 3550 pins[j] = nid; 3551 } 3552 } 3553 } 3554 } 3555 3556 3557 /* 3558 * Parse all pin widgets and store the useful pin nids to cfg 3559 * 3560 * The number of line-outs or any primary output is stored in line_outs, 3561 * and the corresponding output pins are assigned to line_out_pins[], 3562 * in the order of front, rear, CLFE, side, ... 3563 * 3564 * If more extra outputs (speaker and headphone) are found, the pins are 3565 * assisnged to hp_pins[] and speaker_pins[], respectively. If no line-out jack 3566 * is detected, one of speaker of HP pins is assigned as the primary 3567 * output, i.e. to line_out_pins[0]. So, line_outs is always positive 3568 * if any analog output exists. 3569 * 3570 * The analog input pins are assigned to input_pins array. 3571 * The digital input/output pins are assigned to dig_in_pin and dig_out_pin, 3572 * respectively. 3573 */ 3574 int snd_hda_parse_pin_def_config(struct hda_codec *codec, 3575 struct auto_pin_cfg *cfg, 3576 hda_nid_t *ignore_nids) 3577 { 3578 hda_nid_t nid, end_nid; 3579 short seq, assoc_line_out, assoc_speaker; 3580 short sequences_line_out[ARRAY_SIZE(cfg->line_out_pins)]; 3581 short sequences_speaker[ARRAY_SIZE(cfg->speaker_pins)]; 3582 short sequences_hp[ARRAY_SIZE(cfg->hp_pins)]; 3583 3584 memset(cfg, 0, sizeof(*cfg)); 3585 3586 memset(sequences_line_out, 0, sizeof(sequences_line_out)); 3587 memset(sequences_speaker, 0, sizeof(sequences_speaker)); 3588 memset(sequences_hp, 0, sizeof(sequences_hp)); 3589 assoc_line_out = assoc_speaker = 0; 3590 3591 end_nid = codec->start_nid + codec->num_nodes; 3592 for (nid = codec->start_nid; nid < end_nid; nid++) { 3593 unsigned int wid_caps = get_wcaps(codec, nid); 3594 unsigned int wid_type = 3595 (wid_caps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT; 3596 unsigned int def_conf; 3597 short assoc, loc; 3598 3599 /* read all default configuration for pin complex */ 3600 if (wid_type != AC_WID_PIN) 3601 continue; 3602 /* ignore the given nids (e.g. pc-beep returns error) */ 3603 if (ignore_nids && is_in_nid_list(nid, ignore_nids)) 3604 continue; 3605 3606 def_conf = snd_hda_codec_get_pincfg(codec, nid); 3607 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE) 3608 continue; 3609 loc = get_defcfg_location(def_conf); 3610 switch (get_defcfg_device(def_conf)) { 3611 case AC_JACK_LINE_OUT: 3612 seq = get_defcfg_sequence(def_conf); 3613 assoc = get_defcfg_association(def_conf); 3614 3615 if (!(wid_caps & AC_WCAP_STEREO)) 3616 if (!cfg->mono_out_pin) 3617 cfg->mono_out_pin = nid; 3618 if (!assoc) 3619 continue; 3620 if (!assoc_line_out) 3621 assoc_line_out = assoc; 3622 else if (assoc_line_out != assoc) 3623 continue; 3624 if (cfg->line_outs >= ARRAY_SIZE(cfg->line_out_pins)) 3625 continue; 3626 cfg->line_out_pins[cfg->line_outs] = nid; 3627 sequences_line_out[cfg->line_outs] = seq; 3628 cfg->line_outs++; 3629 break; 3630 case AC_JACK_SPEAKER: 3631 seq = get_defcfg_sequence(def_conf); 3632 assoc = get_defcfg_association(def_conf); 3633 if (! assoc) 3634 continue; 3635 if (! assoc_speaker) 3636 assoc_speaker = assoc; 3637 else if (assoc_speaker != assoc) 3638 continue; 3639 if (cfg->speaker_outs >= ARRAY_SIZE(cfg->speaker_pins)) 3640 continue; 3641 cfg->speaker_pins[cfg->speaker_outs] = nid; 3642 sequences_speaker[cfg->speaker_outs] = seq; 3643 cfg->speaker_outs++; 3644 break; 3645 case AC_JACK_HP_OUT: 3646 seq = get_defcfg_sequence(def_conf); 3647 assoc = get_defcfg_association(def_conf); 3648 if (cfg->hp_outs >= ARRAY_SIZE(cfg->hp_pins)) 3649 continue; 3650 cfg->hp_pins[cfg->hp_outs] = nid; 3651 sequences_hp[cfg->hp_outs] = (assoc << 4) | seq; 3652 cfg->hp_outs++; 3653 break; 3654 case AC_JACK_MIC_IN: { 3655 int preferred, alt; 3656 if (loc == AC_JACK_LOC_FRONT) { 3657 preferred = AUTO_PIN_FRONT_MIC; 3658 alt = AUTO_PIN_MIC; 3659 } else { 3660 preferred = AUTO_PIN_MIC; 3661 alt = AUTO_PIN_FRONT_MIC; 3662 } 3663 if (!cfg->input_pins[preferred]) 3664 cfg->input_pins[preferred] = nid; 3665 else if (!cfg->input_pins[alt]) 3666 cfg->input_pins[alt] = nid; 3667 break; 3668 } 3669 case AC_JACK_LINE_IN: 3670 if (loc == AC_JACK_LOC_FRONT) 3671 cfg->input_pins[AUTO_PIN_FRONT_LINE] = nid; 3672 else 3673 cfg->input_pins[AUTO_PIN_LINE] = nid; 3674 break; 3675 case AC_JACK_CD: 3676 cfg->input_pins[AUTO_PIN_CD] = nid; 3677 break; 3678 case AC_JACK_AUX: 3679 cfg->input_pins[AUTO_PIN_AUX] = nid; 3680 break; 3681 case AC_JACK_SPDIF_OUT: 3682 case AC_JACK_DIG_OTHER_OUT: 3683 if (cfg->dig_outs >= ARRAY_SIZE(cfg->dig_out_pins)) 3684 continue; 3685 cfg->dig_out_pins[cfg->dig_outs] = nid; 3686 cfg->dig_out_type[cfg->dig_outs] = 3687 (loc == AC_JACK_LOC_HDMI) ? 3688 HDA_PCM_TYPE_HDMI : HDA_PCM_TYPE_SPDIF; 3689 cfg->dig_outs++; 3690 break; 3691 case AC_JACK_SPDIF_IN: 3692 case AC_JACK_DIG_OTHER_IN: 3693 cfg->dig_in_pin = nid; 3694 if (loc == AC_JACK_LOC_HDMI) 3695 cfg->dig_in_type = HDA_PCM_TYPE_HDMI; 3696 else 3697 cfg->dig_in_type = HDA_PCM_TYPE_SPDIF; 3698 break; 3699 } 3700 } 3701 3702 /* FIX-UP: 3703 * If no line-out is defined but multiple HPs are found, 3704 * some of them might be the real line-outs. 3705 */ 3706 if (!cfg->line_outs && cfg->hp_outs > 1) { 3707 int i = 0; 3708 while (i < cfg->hp_outs) { 3709 /* The real HPs should have the sequence 0x0f */ 3710 if ((sequences_hp[i] & 0x0f) == 0x0f) { 3711 i++; 3712 continue; 3713 } 3714 /* Move it to the line-out table */ 3715 cfg->line_out_pins[cfg->line_outs] = cfg->hp_pins[i]; 3716 sequences_line_out[cfg->line_outs] = sequences_hp[i]; 3717 cfg->line_outs++; 3718 cfg->hp_outs--; 3719 memmove(cfg->hp_pins + i, cfg->hp_pins + i + 1, 3720 sizeof(cfg->hp_pins[0]) * (cfg->hp_outs - i)); 3721 memmove(sequences_hp + i - 1, sequences_hp + i, 3722 sizeof(sequences_hp[0]) * (cfg->hp_outs - i)); 3723 } 3724 } 3725 3726 /* sort by sequence */ 3727 sort_pins_by_sequence(cfg->line_out_pins, sequences_line_out, 3728 cfg->line_outs); 3729 sort_pins_by_sequence(cfg->speaker_pins, sequences_speaker, 3730 cfg->speaker_outs); 3731 sort_pins_by_sequence(cfg->hp_pins, sequences_hp, 3732 cfg->hp_outs); 3733 3734 /* if we have only one mic, make it AUTO_PIN_MIC */ 3735 if (!cfg->input_pins[AUTO_PIN_MIC] && 3736 cfg->input_pins[AUTO_PIN_FRONT_MIC]) { 3737 cfg->input_pins[AUTO_PIN_MIC] = 3738 cfg->input_pins[AUTO_PIN_FRONT_MIC]; 3739 cfg->input_pins[AUTO_PIN_FRONT_MIC] = 0; 3740 } 3741 /* ditto for line-in */ 3742 if (!cfg->input_pins[AUTO_PIN_LINE] && 3743 cfg->input_pins[AUTO_PIN_FRONT_LINE]) { 3744 cfg->input_pins[AUTO_PIN_LINE] = 3745 cfg->input_pins[AUTO_PIN_FRONT_LINE]; 3746 cfg->input_pins[AUTO_PIN_FRONT_LINE] = 0; 3747 } 3748 3749 /* 3750 * FIX-UP: if no line-outs are detected, try to use speaker or HP pin 3751 * as a primary output 3752 */ 3753 if (!cfg->line_outs) { 3754 if (cfg->speaker_outs) { 3755 cfg->line_outs = cfg->speaker_outs; 3756 memcpy(cfg->line_out_pins, cfg->speaker_pins, 3757 sizeof(cfg->speaker_pins)); 3758 cfg->speaker_outs = 0; 3759 memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins)); 3760 cfg->line_out_type = AUTO_PIN_SPEAKER_OUT; 3761 } else if (cfg->hp_outs) { 3762 cfg->line_outs = cfg->hp_outs; 3763 memcpy(cfg->line_out_pins, cfg->hp_pins, 3764 sizeof(cfg->hp_pins)); 3765 cfg->hp_outs = 0; 3766 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins)); 3767 cfg->line_out_type = AUTO_PIN_HP_OUT; 3768 } 3769 } 3770 3771 /* Reorder the surround channels 3772 * ALSA sequence is front/surr/clfe/side 3773 * HDA sequence is: 3774 * 4-ch: front/surr => OK as it is 3775 * 6-ch: front/clfe/surr 3776 * 8-ch: front/clfe/rear/side|fc 3777 */ 3778 switch (cfg->line_outs) { 3779 case 3: 3780 case 4: 3781 nid = cfg->line_out_pins[1]; 3782 cfg->line_out_pins[1] = cfg->line_out_pins[2]; 3783 cfg->line_out_pins[2] = nid; 3784 break; 3785 } 3786 3787 /* 3788 * debug prints of the parsed results 3789 */ 3790 snd_printd("autoconfig: line_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n", 3791 cfg->line_outs, cfg->line_out_pins[0], cfg->line_out_pins[1], 3792 cfg->line_out_pins[2], cfg->line_out_pins[3], 3793 cfg->line_out_pins[4]); 3794 snd_printd(" speaker_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n", 3795 cfg->speaker_outs, cfg->speaker_pins[0], 3796 cfg->speaker_pins[1], cfg->speaker_pins[2], 3797 cfg->speaker_pins[3], cfg->speaker_pins[4]); 3798 snd_printd(" hp_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n", 3799 cfg->hp_outs, cfg->hp_pins[0], 3800 cfg->hp_pins[1], cfg->hp_pins[2], 3801 cfg->hp_pins[3], cfg->hp_pins[4]); 3802 snd_printd(" mono: mono_out=0x%x\n", cfg->mono_out_pin); 3803 if (cfg->dig_outs) 3804 snd_printd(" dig-out=0x%x/0x%x\n", 3805 cfg->dig_out_pins[0], cfg->dig_out_pins[1]); 3806 snd_printd(" inputs: mic=0x%x, fmic=0x%x, line=0x%x, fline=0x%x," 3807 " cd=0x%x, aux=0x%x\n", 3808 cfg->input_pins[AUTO_PIN_MIC], 3809 cfg->input_pins[AUTO_PIN_FRONT_MIC], 3810 cfg->input_pins[AUTO_PIN_LINE], 3811 cfg->input_pins[AUTO_PIN_FRONT_LINE], 3812 cfg->input_pins[AUTO_PIN_CD], 3813 cfg->input_pins[AUTO_PIN_AUX]); 3814 if (cfg->dig_in_pin) 3815 snd_printd(" dig-in=0x%x\n", cfg->dig_in_pin); 3816 3817 return 0; 3818 } 3819 EXPORT_SYMBOL_HDA(snd_hda_parse_pin_def_config); 3820 3821 /* labels for input pins */ 3822 const char *auto_pin_cfg_labels[AUTO_PIN_LAST] = { 3823 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux" 3824 }; 3825 EXPORT_SYMBOL_HDA(auto_pin_cfg_labels); 3826 3827 3828 #ifdef CONFIG_PM 3829 /* 3830 * power management 3831 */ 3832 3833 /** 3834 * snd_hda_suspend - suspend the codecs 3835 * @bus: the HDA bus 3836 * @state: suspsend state 3837 * 3838 * Returns 0 if successful. 3839 */ 3840 int snd_hda_suspend(struct hda_bus *bus, pm_message_t state) 3841 { 3842 struct hda_codec *codec; 3843 3844 list_for_each_entry(codec, &bus->codec_list, list) { 3845 #ifdef CONFIG_SND_HDA_POWER_SAVE 3846 if (!codec->power_on) 3847 continue; 3848 #endif 3849 hda_call_codec_suspend(codec); 3850 } 3851 return 0; 3852 } 3853 EXPORT_SYMBOL_HDA(snd_hda_suspend); 3854 3855 /** 3856 * snd_hda_resume - resume the codecs 3857 * @bus: the HDA bus 3858 * 3859 * Returns 0 if successful. 3860 * 3861 * This fucntion is defined only when POWER_SAVE isn't set. 3862 * In the power-save mode, the codec is resumed dynamically. 3863 */ 3864 int snd_hda_resume(struct hda_bus *bus) 3865 { 3866 struct hda_codec *codec; 3867 3868 list_for_each_entry(codec, &bus->codec_list, list) { 3869 if (snd_hda_codec_needs_resume(codec)) 3870 hda_call_codec_resume(codec); 3871 } 3872 return 0; 3873 } 3874 EXPORT_SYMBOL_HDA(snd_hda_resume); 3875 #endif /* CONFIG_PM */ 3876 3877 /* 3878 * generic arrays 3879 */ 3880 3881 /* get a new element from the given array 3882 * if it exceeds the pre-allocated array size, re-allocate the array 3883 */ 3884 void *snd_array_new(struct snd_array *array) 3885 { 3886 if (array->used >= array->alloced) { 3887 int num = array->alloced + array->alloc_align; 3888 void *nlist; 3889 if (snd_BUG_ON(num >= 4096)) 3890 return NULL; 3891 nlist = kcalloc(num + 1, array->elem_size, GFP_KERNEL); 3892 if (!nlist) 3893 return NULL; 3894 if (array->list) { 3895 memcpy(nlist, array->list, 3896 array->elem_size * array->alloced); 3897 kfree(array->list); 3898 } 3899 array->list = nlist; 3900 array->alloced = num; 3901 } 3902 return snd_array_elem(array, array->used++); 3903 } 3904 EXPORT_SYMBOL_HDA(snd_array_new); 3905 3906 /* free the given array elements */ 3907 void snd_array_free(struct snd_array *array) 3908 { 3909 kfree(array->list); 3910 array->used = 0; 3911 array->alloced = 0; 3912 array->list = NULL; 3913 } 3914 EXPORT_SYMBOL_HDA(snd_array_free); 3915 3916 /* 3917 * used by hda_proc.c and hda_eld.c 3918 */ 3919 void snd_print_pcm_rates(int pcm, char *buf, int buflen) 3920 { 3921 static unsigned int rates[] = { 3922 8000, 11025, 16000, 22050, 32000, 44100, 48000, 88200, 3923 96000, 176400, 192000, 384000 3924 }; 3925 int i, j; 3926 3927 for (i = 0, j = 0; i < ARRAY_SIZE(rates); i++) 3928 if (pcm & (1 << i)) 3929 j += snprintf(buf + j, buflen - j, " %d", rates[i]); 3930 3931 buf[j] = '\0'; /* necessary when j == 0 */ 3932 } 3933 EXPORT_SYMBOL_HDA(snd_print_pcm_rates); 3934 3935 void snd_print_pcm_bits(int pcm, char *buf, int buflen) 3936 { 3937 static unsigned int bits[] = { 8, 16, 20, 24, 32 }; 3938 int i, j; 3939 3940 for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++) 3941 if (pcm & (AC_SUPPCM_BITS_8 << i)) 3942 j += snprintf(buf + j, buflen - j, " %d", bits[i]); 3943 3944 buf[j] = '\0'; /* necessary when j == 0 */ 3945 } 3946 EXPORT_SYMBOL_HDA(snd_print_pcm_bits); 3947 3948 MODULE_DESCRIPTION("HDA codec core"); 3949 MODULE_LICENSE("GPL"); 3950