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 = build_cmd_cache_key(nid, verb); 2254 c = get_alloc_hash(&codec->cmd_cache, key); 2255 if (c) 2256 c->val = parm; 2257 } 2258 mutex_unlock(&bus->cmd_mutex); 2259 snd_hda_power_down(codec); 2260 return err; 2261 } 2262 EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache); 2263 2264 /* resume the all commands from the cache */ 2265 void snd_hda_codec_resume_cache(struct hda_codec *codec) 2266 { 2267 struct hda_cache_head *buffer = codec->cmd_cache.buf.list; 2268 int i; 2269 2270 for (i = 0; i < codec->cmd_cache.buf.used; i++, buffer++) { 2271 u32 key = buffer->key; 2272 if (!key) 2273 continue; 2274 snd_hda_codec_write(codec, get_cmd_cache_nid(key), 0, 2275 get_cmd_cache_cmd(key), buffer->val); 2276 } 2277 } 2278 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_cache); 2279 2280 /** 2281 * snd_hda_sequence_write_cache - sequence writes with caching 2282 * @codec: the HDA codec 2283 * @seq: VERB array to send 2284 * 2285 * Send the commands sequentially from the given array. 2286 * Thte commands are recorded on cache for power-save and resume. 2287 * The array must be terminated with NID=0. 2288 */ 2289 void snd_hda_sequence_write_cache(struct hda_codec *codec, 2290 const struct hda_verb *seq) 2291 { 2292 for (; seq->nid; seq++) 2293 snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb, 2294 seq->param); 2295 } 2296 EXPORT_SYMBOL_HDA(snd_hda_sequence_write_cache); 2297 #endif /* SND_HDA_NEEDS_RESUME */ 2298 2299 /* 2300 * set power state of the codec 2301 */ 2302 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg, 2303 unsigned int power_state) 2304 { 2305 hda_nid_t nid; 2306 int i; 2307 2308 snd_hda_codec_write(codec, fg, 0, AC_VERB_SET_POWER_STATE, 2309 power_state); 2310 msleep(10); /* partial workaround for "azx_get_response timeout" */ 2311 2312 nid = codec->start_nid; 2313 for (i = 0; i < codec->num_nodes; i++, nid++) { 2314 unsigned int wcaps = get_wcaps(codec, nid); 2315 if (wcaps & AC_WCAP_POWER) { 2316 unsigned int wid_type = (wcaps & AC_WCAP_TYPE) >> 2317 AC_WCAP_TYPE_SHIFT; 2318 if (wid_type == AC_WID_PIN) { 2319 unsigned int pincap; 2320 /* 2321 * don't power down the widget if it controls 2322 * eapd and EAPD_BTLENABLE is set. 2323 */ 2324 pincap = snd_hda_query_pin_caps(codec, nid); 2325 if (pincap & AC_PINCAP_EAPD) { 2326 int eapd = snd_hda_codec_read(codec, 2327 nid, 0, 2328 AC_VERB_GET_EAPD_BTLENABLE, 0); 2329 eapd &= 0x02; 2330 if (power_state == AC_PWRST_D3 && eapd) 2331 continue; 2332 } 2333 } 2334 snd_hda_codec_write(codec, nid, 0, 2335 AC_VERB_SET_POWER_STATE, 2336 power_state); 2337 } 2338 } 2339 2340 if (power_state == AC_PWRST_D0) { 2341 unsigned long end_time; 2342 int state; 2343 msleep(10); 2344 /* wait until the codec reachs to D0 */ 2345 end_time = jiffies + msecs_to_jiffies(500); 2346 do { 2347 state = snd_hda_codec_read(codec, fg, 0, 2348 AC_VERB_GET_POWER_STATE, 0); 2349 if (state == power_state) 2350 break; 2351 msleep(1); 2352 } while (time_after_eq(end_time, jiffies)); 2353 } 2354 } 2355 2356 #ifdef CONFIG_SND_HDA_HWDEP 2357 /* execute additional init verbs */ 2358 static void hda_exec_init_verbs(struct hda_codec *codec) 2359 { 2360 if (codec->init_verbs.list) 2361 snd_hda_sequence_write(codec, codec->init_verbs.list); 2362 } 2363 #else 2364 static inline void hda_exec_init_verbs(struct hda_codec *codec) {} 2365 #endif 2366 2367 #ifdef SND_HDA_NEEDS_RESUME 2368 /* 2369 * call suspend and power-down; used both from PM and power-save 2370 */ 2371 static void hda_call_codec_suspend(struct hda_codec *codec) 2372 { 2373 if (codec->patch_ops.suspend) 2374 codec->patch_ops.suspend(codec, PMSG_SUSPEND); 2375 hda_set_power_state(codec, 2376 codec->afg ? codec->afg : codec->mfg, 2377 AC_PWRST_D3); 2378 #ifdef CONFIG_SND_HDA_POWER_SAVE 2379 cancel_delayed_work(&codec->power_work); 2380 codec->power_on = 0; 2381 codec->power_transition = 0; 2382 #endif 2383 } 2384 2385 /* 2386 * kick up codec; used both from PM and power-save 2387 */ 2388 static void hda_call_codec_resume(struct hda_codec *codec) 2389 { 2390 hda_set_power_state(codec, 2391 codec->afg ? codec->afg : codec->mfg, 2392 AC_PWRST_D0); 2393 restore_pincfgs(codec); /* restore all current pin configs */ 2394 hda_exec_init_verbs(codec); 2395 if (codec->patch_ops.resume) 2396 codec->patch_ops.resume(codec); 2397 else { 2398 if (codec->patch_ops.init) 2399 codec->patch_ops.init(codec); 2400 snd_hda_codec_resume_amp(codec); 2401 snd_hda_codec_resume_cache(codec); 2402 } 2403 } 2404 #endif /* SND_HDA_NEEDS_RESUME */ 2405 2406 2407 /** 2408 * snd_hda_build_controls - build mixer controls 2409 * @bus: the BUS 2410 * 2411 * Creates mixer controls for each codec included in the bus. 2412 * 2413 * Returns 0 if successful, otherwise a negative error code. 2414 */ 2415 int /*__devinit*/ snd_hda_build_controls(struct hda_bus *bus) 2416 { 2417 struct hda_codec *codec; 2418 2419 list_for_each_entry(codec, &bus->codec_list, list) { 2420 int err = snd_hda_codec_build_controls(codec); 2421 if (err < 0) { 2422 printk(KERN_ERR "hda_codec: cannot build controls" 2423 "for #%d (error %d)\n", codec->addr, err); 2424 err = snd_hda_codec_reset(codec); 2425 if (err < 0) { 2426 printk(KERN_ERR 2427 "hda_codec: cannot revert codec\n"); 2428 return err; 2429 } 2430 } 2431 } 2432 return 0; 2433 } 2434 EXPORT_SYMBOL_HDA(snd_hda_build_controls); 2435 2436 int snd_hda_codec_build_controls(struct hda_codec *codec) 2437 { 2438 int err = 0; 2439 hda_exec_init_verbs(codec); 2440 /* continue to initialize... */ 2441 if (codec->patch_ops.init) 2442 err = codec->patch_ops.init(codec); 2443 if (!err && codec->patch_ops.build_controls) 2444 err = codec->patch_ops.build_controls(codec); 2445 if (err < 0) 2446 return err; 2447 return 0; 2448 } 2449 2450 /* 2451 * stream formats 2452 */ 2453 struct hda_rate_tbl { 2454 unsigned int hz; 2455 unsigned int alsa_bits; 2456 unsigned int hda_fmt; 2457 }; 2458 2459 static struct hda_rate_tbl rate_bits[] = { 2460 /* rate in Hz, ALSA rate bitmask, HDA format value */ 2461 2462 /* autodetected value used in snd_hda_query_supported_pcm */ 2463 { 8000, SNDRV_PCM_RATE_8000, 0x0500 }, /* 1/6 x 48 */ 2464 { 11025, SNDRV_PCM_RATE_11025, 0x4300 }, /* 1/4 x 44 */ 2465 { 16000, SNDRV_PCM_RATE_16000, 0x0200 }, /* 1/3 x 48 */ 2466 { 22050, SNDRV_PCM_RATE_22050, 0x4100 }, /* 1/2 x 44 */ 2467 { 32000, SNDRV_PCM_RATE_32000, 0x0a00 }, /* 2/3 x 48 */ 2468 { 44100, SNDRV_PCM_RATE_44100, 0x4000 }, /* 44 */ 2469 { 48000, SNDRV_PCM_RATE_48000, 0x0000 }, /* 48 */ 2470 { 88200, SNDRV_PCM_RATE_88200, 0x4800 }, /* 2 x 44 */ 2471 { 96000, SNDRV_PCM_RATE_96000, 0x0800 }, /* 2 x 48 */ 2472 { 176400, SNDRV_PCM_RATE_176400, 0x5800 },/* 4 x 44 */ 2473 { 192000, SNDRV_PCM_RATE_192000, 0x1800 }, /* 4 x 48 */ 2474 #define AC_PAR_PCM_RATE_BITS 11 2475 /* up to bits 10, 384kHZ isn't supported properly */ 2476 2477 /* not autodetected value */ 2478 { 9600, SNDRV_PCM_RATE_KNOT, 0x0400 }, /* 1/5 x 48 */ 2479 2480 { 0 } /* terminator */ 2481 }; 2482 2483 /** 2484 * snd_hda_calc_stream_format - calculate format bitset 2485 * @rate: the sample rate 2486 * @channels: the number of channels 2487 * @format: the PCM format (SNDRV_PCM_FORMAT_XXX) 2488 * @maxbps: the max. bps 2489 * 2490 * Calculate the format bitset from the given rate, channels and th PCM format. 2491 * 2492 * Return zero if invalid. 2493 */ 2494 unsigned int snd_hda_calc_stream_format(unsigned int rate, 2495 unsigned int channels, 2496 unsigned int format, 2497 unsigned int maxbps) 2498 { 2499 int i; 2500 unsigned int val = 0; 2501 2502 for (i = 0; rate_bits[i].hz; i++) 2503 if (rate_bits[i].hz == rate) { 2504 val = rate_bits[i].hda_fmt; 2505 break; 2506 } 2507 if (!rate_bits[i].hz) { 2508 snd_printdd("invalid rate %d\n", rate); 2509 return 0; 2510 } 2511 2512 if (channels == 0 || channels > 8) { 2513 snd_printdd("invalid channels %d\n", channels); 2514 return 0; 2515 } 2516 val |= channels - 1; 2517 2518 switch (snd_pcm_format_width(format)) { 2519 case 8: val |= 0x00; break; 2520 case 16: val |= 0x10; break; 2521 case 20: 2522 case 24: 2523 case 32: 2524 if (maxbps >= 32) 2525 val |= 0x40; 2526 else if (maxbps >= 24) 2527 val |= 0x30; 2528 else 2529 val |= 0x20; 2530 break; 2531 default: 2532 snd_printdd("invalid format width %d\n", 2533 snd_pcm_format_width(format)); 2534 return 0; 2535 } 2536 2537 return val; 2538 } 2539 EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format); 2540 2541 /** 2542 * snd_hda_query_supported_pcm - query the supported PCM rates and formats 2543 * @codec: the HDA codec 2544 * @nid: NID to query 2545 * @ratesp: the pointer to store the detected rate bitflags 2546 * @formatsp: the pointer to store the detected formats 2547 * @bpsp: the pointer to store the detected format widths 2548 * 2549 * Queries the supported PCM rates and formats. The NULL @ratesp, @formatsp 2550 * or @bsps argument is ignored. 2551 * 2552 * Returns 0 if successful, otherwise a negative error code. 2553 */ 2554 static int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid, 2555 u32 *ratesp, u64 *formatsp, unsigned int *bpsp) 2556 { 2557 unsigned int i, val, wcaps; 2558 2559 val = 0; 2560 wcaps = get_wcaps(codec, nid); 2561 if (nid != codec->afg && (wcaps & AC_WCAP_FORMAT_OVRD)) { 2562 val = snd_hda_param_read(codec, nid, AC_PAR_PCM); 2563 if (val == -1) 2564 return -EIO; 2565 } 2566 if (!val) 2567 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM); 2568 2569 if (ratesp) { 2570 u32 rates = 0; 2571 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) { 2572 if (val & (1 << i)) 2573 rates |= rate_bits[i].alsa_bits; 2574 } 2575 if (rates == 0) { 2576 snd_printk(KERN_ERR "hda_codec: rates == 0 " 2577 "(nid=0x%x, val=0x%x, ovrd=%i)\n", 2578 nid, val, 2579 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0); 2580 return -EIO; 2581 } 2582 *ratesp = rates; 2583 } 2584 2585 if (formatsp || bpsp) { 2586 u64 formats = 0; 2587 unsigned int streams, bps; 2588 2589 streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM); 2590 if (streams == -1) 2591 return -EIO; 2592 if (!streams) { 2593 streams = snd_hda_param_read(codec, codec->afg, 2594 AC_PAR_STREAM); 2595 if (streams == -1) 2596 return -EIO; 2597 } 2598 2599 bps = 0; 2600 if (streams & AC_SUPFMT_PCM) { 2601 if (val & AC_SUPPCM_BITS_8) { 2602 formats |= SNDRV_PCM_FMTBIT_U8; 2603 bps = 8; 2604 } 2605 if (val & AC_SUPPCM_BITS_16) { 2606 formats |= SNDRV_PCM_FMTBIT_S16_LE; 2607 bps = 16; 2608 } 2609 if (wcaps & AC_WCAP_DIGITAL) { 2610 if (val & AC_SUPPCM_BITS_32) 2611 formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE; 2612 if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24)) 2613 formats |= SNDRV_PCM_FMTBIT_S32_LE; 2614 if (val & AC_SUPPCM_BITS_24) 2615 bps = 24; 2616 else if (val & AC_SUPPCM_BITS_20) 2617 bps = 20; 2618 } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24| 2619 AC_SUPPCM_BITS_32)) { 2620 formats |= SNDRV_PCM_FMTBIT_S32_LE; 2621 if (val & AC_SUPPCM_BITS_32) 2622 bps = 32; 2623 else if (val & AC_SUPPCM_BITS_24) 2624 bps = 24; 2625 else if (val & AC_SUPPCM_BITS_20) 2626 bps = 20; 2627 } 2628 } 2629 else if (streams == AC_SUPFMT_FLOAT32) { 2630 /* should be exclusive */ 2631 formats |= SNDRV_PCM_FMTBIT_FLOAT_LE; 2632 bps = 32; 2633 } else if (streams == AC_SUPFMT_AC3) { 2634 /* should be exclusive */ 2635 /* temporary hack: we have still no proper support 2636 * for the direct AC3 stream... 2637 */ 2638 formats |= SNDRV_PCM_FMTBIT_U8; 2639 bps = 8; 2640 } 2641 if (formats == 0) { 2642 snd_printk(KERN_ERR "hda_codec: formats == 0 " 2643 "(nid=0x%x, val=0x%x, ovrd=%i, " 2644 "streams=0x%x)\n", 2645 nid, val, 2646 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0, 2647 streams); 2648 return -EIO; 2649 } 2650 if (formatsp) 2651 *formatsp = formats; 2652 if (bpsp) 2653 *bpsp = bps; 2654 } 2655 2656 return 0; 2657 } 2658 2659 /** 2660 * snd_hda_is_supported_format - check whether the given node supports 2661 * the format val 2662 * 2663 * Returns 1 if supported, 0 if not. 2664 */ 2665 int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid, 2666 unsigned int format) 2667 { 2668 int i; 2669 unsigned int val = 0, rate, stream; 2670 2671 if (nid != codec->afg && 2672 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD)) { 2673 val = snd_hda_param_read(codec, nid, AC_PAR_PCM); 2674 if (val == -1) 2675 return 0; 2676 } 2677 if (!val) { 2678 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM); 2679 if (val == -1) 2680 return 0; 2681 } 2682 2683 rate = format & 0xff00; 2684 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) 2685 if (rate_bits[i].hda_fmt == rate) { 2686 if (val & (1 << i)) 2687 break; 2688 return 0; 2689 } 2690 if (i >= AC_PAR_PCM_RATE_BITS) 2691 return 0; 2692 2693 stream = snd_hda_param_read(codec, nid, AC_PAR_STREAM); 2694 if (stream == -1) 2695 return 0; 2696 if (!stream && nid != codec->afg) 2697 stream = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM); 2698 if (!stream || stream == -1) 2699 return 0; 2700 2701 if (stream & AC_SUPFMT_PCM) { 2702 switch (format & 0xf0) { 2703 case 0x00: 2704 if (!(val & AC_SUPPCM_BITS_8)) 2705 return 0; 2706 break; 2707 case 0x10: 2708 if (!(val & AC_SUPPCM_BITS_16)) 2709 return 0; 2710 break; 2711 case 0x20: 2712 if (!(val & AC_SUPPCM_BITS_20)) 2713 return 0; 2714 break; 2715 case 0x30: 2716 if (!(val & AC_SUPPCM_BITS_24)) 2717 return 0; 2718 break; 2719 case 0x40: 2720 if (!(val & AC_SUPPCM_BITS_32)) 2721 return 0; 2722 break; 2723 default: 2724 return 0; 2725 } 2726 } else { 2727 /* FIXME: check for float32 and AC3? */ 2728 } 2729 2730 return 1; 2731 } 2732 EXPORT_SYMBOL_HDA(snd_hda_is_supported_format); 2733 2734 /* 2735 * PCM stuff 2736 */ 2737 static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo, 2738 struct hda_codec *codec, 2739 struct snd_pcm_substream *substream) 2740 { 2741 return 0; 2742 } 2743 2744 static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo, 2745 struct hda_codec *codec, 2746 unsigned int stream_tag, 2747 unsigned int format, 2748 struct snd_pcm_substream *substream) 2749 { 2750 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format); 2751 return 0; 2752 } 2753 2754 static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo, 2755 struct hda_codec *codec, 2756 struct snd_pcm_substream *substream) 2757 { 2758 snd_hda_codec_cleanup_stream(codec, hinfo->nid); 2759 return 0; 2760 } 2761 2762 static int set_pcm_default_values(struct hda_codec *codec, 2763 struct hda_pcm_stream *info) 2764 { 2765 int err; 2766 2767 /* query support PCM information from the given NID */ 2768 if (info->nid && (!info->rates || !info->formats)) { 2769 err = snd_hda_query_supported_pcm(codec, info->nid, 2770 info->rates ? NULL : &info->rates, 2771 info->formats ? NULL : &info->formats, 2772 info->maxbps ? NULL : &info->maxbps); 2773 if (err < 0) 2774 return err; 2775 } 2776 if (info->ops.open == NULL) 2777 info->ops.open = hda_pcm_default_open_close; 2778 if (info->ops.close == NULL) 2779 info->ops.close = hda_pcm_default_open_close; 2780 if (info->ops.prepare == NULL) { 2781 if (snd_BUG_ON(!info->nid)) 2782 return -EINVAL; 2783 info->ops.prepare = hda_pcm_default_prepare; 2784 } 2785 if (info->ops.cleanup == NULL) { 2786 if (snd_BUG_ON(!info->nid)) 2787 return -EINVAL; 2788 info->ops.cleanup = hda_pcm_default_cleanup; 2789 } 2790 return 0; 2791 } 2792 2793 /* 2794 * get the empty PCM device number to assign 2795 */ 2796 static int get_empty_pcm_device(struct hda_bus *bus, int type) 2797 { 2798 static const char *dev_name[HDA_PCM_NTYPES] = { 2799 "Audio", "SPDIF", "HDMI", "Modem" 2800 }; 2801 /* starting device index for each PCM type */ 2802 static int dev_idx[HDA_PCM_NTYPES] = { 2803 [HDA_PCM_TYPE_AUDIO] = 0, 2804 [HDA_PCM_TYPE_SPDIF] = 1, 2805 [HDA_PCM_TYPE_HDMI] = 3, 2806 [HDA_PCM_TYPE_MODEM] = 6 2807 }; 2808 /* normal audio device indices; not linear to keep compatibility */ 2809 static int audio_idx[4] = { 0, 2, 4, 5 }; 2810 int i, dev; 2811 2812 switch (type) { 2813 case HDA_PCM_TYPE_AUDIO: 2814 for (i = 0; i < ARRAY_SIZE(audio_idx); i++) { 2815 dev = audio_idx[i]; 2816 if (!test_bit(dev, bus->pcm_dev_bits)) 2817 goto ok; 2818 } 2819 snd_printk(KERN_WARNING "Too many audio devices\n"); 2820 return -EAGAIN; 2821 case HDA_PCM_TYPE_SPDIF: 2822 case HDA_PCM_TYPE_HDMI: 2823 case HDA_PCM_TYPE_MODEM: 2824 dev = dev_idx[type]; 2825 if (test_bit(dev, bus->pcm_dev_bits)) { 2826 snd_printk(KERN_WARNING "%s already defined\n", 2827 dev_name[type]); 2828 return -EAGAIN; 2829 } 2830 break; 2831 default: 2832 snd_printk(KERN_WARNING "Invalid PCM type %d\n", type); 2833 return -EINVAL; 2834 } 2835 ok: 2836 set_bit(dev, bus->pcm_dev_bits); 2837 return dev; 2838 } 2839 2840 /* 2841 * attach a new PCM stream 2842 */ 2843 static int snd_hda_attach_pcm(struct hda_codec *codec, struct hda_pcm *pcm) 2844 { 2845 struct hda_bus *bus = codec->bus; 2846 struct hda_pcm_stream *info; 2847 int stream, err; 2848 2849 if (snd_BUG_ON(!pcm->name)) 2850 return -EINVAL; 2851 for (stream = 0; stream < 2; stream++) { 2852 info = &pcm->stream[stream]; 2853 if (info->substreams) { 2854 err = set_pcm_default_values(codec, info); 2855 if (err < 0) 2856 return err; 2857 } 2858 } 2859 return bus->ops.attach_pcm(bus, codec, pcm); 2860 } 2861 2862 /* assign all PCMs of the given codec */ 2863 int snd_hda_codec_build_pcms(struct hda_codec *codec) 2864 { 2865 unsigned int pcm; 2866 int err; 2867 2868 if (!codec->num_pcms) { 2869 if (!codec->patch_ops.build_pcms) 2870 return 0; 2871 err = codec->patch_ops.build_pcms(codec); 2872 if (err < 0) { 2873 printk(KERN_ERR "hda_codec: cannot build PCMs" 2874 "for #%d (error %d)\n", codec->addr, err); 2875 err = snd_hda_codec_reset(codec); 2876 if (err < 0) { 2877 printk(KERN_ERR 2878 "hda_codec: cannot revert codec\n"); 2879 return err; 2880 } 2881 } 2882 } 2883 for (pcm = 0; pcm < codec->num_pcms; pcm++) { 2884 struct hda_pcm *cpcm = &codec->pcm_info[pcm]; 2885 int dev; 2886 2887 if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams) 2888 continue; /* no substreams assigned */ 2889 2890 if (!cpcm->pcm) { 2891 dev = get_empty_pcm_device(codec->bus, cpcm->pcm_type); 2892 if (dev < 0) 2893 continue; /* no fatal error */ 2894 cpcm->device = dev; 2895 err = snd_hda_attach_pcm(codec, cpcm); 2896 if (err < 0) { 2897 printk(KERN_ERR "hda_codec: cannot attach " 2898 "PCM stream %d for codec #%d\n", 2899 dev, codec->addr); 2900 continue; /* no fatal error */ 2901 } 2902 } 2903 } 2904 return 0; 2905 } 2906 2907 /** 2908 * snd_hda_build_pcms - build PCM information 2909 * @bus: the BUS 2910 * 2911 * Create PCM information for each codec included in the bus. 2912 * 2913 * The build_pcms codec patch is requested to set up codec->num_pcms and 2914 * codec->pcm_info properly. The array is referred by the top-level driver 2915 * to create its PCM instances. 2916 * The allocated codec->pcm_info should be released in codec->patch_ops.free 2917 * callback. 2918 * 2919 * At least, substreams, channels_min and channels_max must be filled for 2920 * each stream. substreams = 0 indicates that the stream doesn't exist. 2921 * When rates and/or formats are zero, the supported values are queried 2922 * from the given nid. The nid is used also by the default ops.prepare 2923 * and ops.cleanup callbacks. 2924 * 2925 * The driver needs to call ops.open in its open callback. Similarly, 2926 * ops.close is supposed to be called in the close callback. 2927 * ops.prepare should be called in the prepare or hw_params callback 2928 * with the proper parameters for set up. 2929 * ops.cleanup should be called in hw_free for clean up of streams. 2930 * 2931 * This function returns 0 if successfull, or a negative error code. 2932 */ 2933 int __devinit snd_hda_build_pcms(struct hda_bus *bus) 2934 { 2935 struct hda_codec *codec; 2936 2937 list_for_each_entry(codec, &bus->codec_list, list) { 2938 int err = snd_hda_codec_build_pcms(codec); 2939 if (err < 0) 2940 return err; 2941 } 2942 return 0; 2943 } 2944 EXPORT_SYMBOL_HDA(snd_hda_build_pcms); 2945 2946 /** 2947 * snd_hda_check_board_config - compare the current codec with the config table 2948 * @codec: the HDA codec 2949 * @num_configs: number of config enums 2950 * @models: array of model name strings 2951 * @tbl: configuration table, terminated by null entries 2952 * 2953 * Compares the modelname or PCI subsystem id of the current codec with the 2954 * given configuration table. If a matching entry is found, returns its 2955 * config value (supposed to be 0 or positive). 2956 * 2957 * If no entries are matching, the function returns a negative value. 2958 */ 2959 int snd_hda_check_board_config(struct hda_codec *codec, 2960 int num_configs, const char **models, 2961 const struct snd_pci_quirk *tbl) 2962 { 2963 if (codec->modelname && models) { 2964 int i; 2965 for (i = 0; i < num_configs; i++) { 2966 if (models[i] && 2967 !strcmp(codec->modelname, models[i])) { 2968 snd_printd(KERN_INFO "hda_codec: model '%s' is " 2969 "selected\n", models[i]); 2970 return i; 2971 } 2972 } 2973 } 2974 2975 if (!codec->bus->pci || !tbl) 2976 return -1; 2977 2978 tbl = snd_pci_quirk_lookup(codec->bus->pci, tbl); 2979 if (!tbl) 2980 return -1; 2981 if (tbl->value >= 0 && tbl->value < num_configs) { 2982 #ifdef CONFIG_SND_DEBUG_VERBOSE 2983 char tmp[10]; 2984 const char *model = NULL; 2985 if (models) 2986 model = models[tbl->value]; 2987 if (!model) { 2988 sprintf(tmp, "#%d", tbl->value); 2989 model = tmp; 2990 } 2991 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected " 2992 "for config %x:%x (%s)\n", 2993 model, tbl->subvendor, tbl->subdevice, 2994 (tbl->name ? tbl->name : "Unknown device")); 2995 #endif 2996 return tbl->value; 2997 } 2998 return -1; 2999 } 3000 EXPORT_SYMBOL_HDA(snd_hda_check_board_config); 3001 3002 /** 3003 * snd_hda_check_board_codec_sid_config - compare the current codec 3004 subsystem ID with the 3005 config table 3006 3007 This is important for Gateway notebooks with SB450 HDA Audio 3008 where the vendor ID of the PCI device is: 3009 ATI Technologies Inc SB450 HDA Audio [1002:437b] 3010 and the vendor/subvendor are found only at the codec. 3011 3012 * @codec: the HDA codec 3013 * @num_configs: number of config enums 3014 * @models: array of model name strings 3015 * @tbl: configuration table, terminated by null entries 3016 * 3017 * Compares the modelname or PCI subsystem id of the current codec with the 3018 * given configuration table. If a matching entry is found, returns its 3019 * config value (supposed to be 0 or positive). 3020 * 3021 * If no entries are matching, the function returns a negative value. 3022 */ 3023 int snd_hda_check_board_codec_sid_config(struct hda_codec *codec, 3024 int num_configs, const char **models, 3025 const struct snd_pci_quirk *tbl) 3026 { 3027 const struct snd_pci_quirk *q; 3028 3029 /* Search for codec ID */ 3030 for (q = tbl; q->subvendor; q++) { 3031 unsigned long vendorid = (q->subdevice) | (q->subvendor << 16); 3032 3033 if (vendorid == codec->subsystem_id) 3034 break; 3035 } 3036 3037 if (!q->subvendor) 3038 return -1; 3039 3040 tbl = q; 3041 3042 if (tbl->value >= 0 && tbl->value < num_configs) { 3043 #ifdef CONFIG_SND_DEBUG_DETECT 3044 char tmp[10]; 3045 const char *model = NULL; 3046 if (models) 3047 model = models[tbl->value]; 3048 if (!model) { 3049 sprintf(tmp, "#%d", tbl->value); 3050 model = tmp; 3051 } 3052 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected " 3053 "for config %x:%x (%s)\n", 3054 model, tbl->subvendor, tbl->subdevice, 3055 (tbl->name ? tbl->name : "Unknown device")); 3056 #endif 3057 return tbl->value; 3058 } 3059 return -1; 3060 } 3061 EXPORT_SYMBOL_HDA(snd_hda_check_board_codec_sid_config); 3062 3063 /** 3064 * snd_hda_add_new_ctls - create controls from the array 3065 * @codec: the HDA codec 3066 * @knew: the array of struct snd_kcontrol_new 3067 * 3068 * This helper function creates and add new controls in the given array. 3069 * The array must be terminated with an empty entry as terminator. 3070 * 3071 * Returns 0 if successful, or a negative error code. 3072 */ 3073 int snd_hda_add_new_ctls(struct hda_codec *codec, struct snd_kcontrol_new *knew) 3074 { 3075 int err; 3076 3077 for (; knew->name; knew++) { 3078 struct snd_kcontrol *kctl; 3079 kctl = snd_ctl_new1(knew, codec); 3080 if (!kctl) 3081 return -ENOMEM; 3082 err = snd_hda_ctl_add(codec, kctl); 3083 if (err < 0) { 3084 if (!codec->addr) 3085 return err; 3086 kctl = snd_ctl_new1(knew, codec); 3087 if (!kctl) 3088 return -ENOMEM; 3089 kctl->id.device = codec->addr; 3090 err = snd_hda_ctl_add(codec, kctl); 3091 if (err < 0) 3092 return err; 3093 } 3094 } 3095 return 0; 3096 } 3097 EXPORT_SYMBOL_HDA(snd_hda_add_new_ctls); 3098 3099 #ifdef CONFIG_SND_HDA_POWER_SAVE 3100 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg, 3101 unsigned int power_state); 3102 3103 static void hda_power_work(struct work_struct *work) 3104 { 3105 struct hda_codec *codec = 3106 container_of(work, struct hda_codec, power_work.work); 3107 struct hda_bus *bus = codec->bus; 3108 3109 if (!codec->power_on || codec->power_count) { 3110 codec->power_transition = 0; 3111 return; 3112 } 3113 3114 hda_call_codec_suspend(codec); 3115 if (bus->ops.pm_notify) 3116 bus->ops.pm_notify(bus); 3117 } 3118 3119 static void hda_keep_power_on(struct hda_codec *codec) 3120 { 3121 codec->power_count++; 3122 codec->power_on = 1; 3123 } 3124 3125 void snd_hda_power_up(struct hda_codec *codec) 3126 { 3127 struct hda_bus *bus = codec->bus; 3128 3129 codec->power_count++; 3130 if (codec->power_on || codec->power_transition) 3131 return; 3132 3133 codec->power_on = 1; 3134 if (bus->ops.pm_notify) 3135 bus->ops.pm_notify(bus); 3136 hda_call_codec_resume(codec); 3137 cancel_delayed_work(&codec->power_work); 3138 codec->power_transition = 0; 3139 } 3140 EXPORT_SYMBOL_HDA(snd_hda_power_up); 3141 3142 #define power_save(codec) \ 3143 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0) 3144 3145 #define power_save(codec) \ 3146 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0) 3147 3148 void snd_hda_power_down(struct hda_codec *codec) 3149 { 3150 --codec->power_count; 3151 if (!codec->power_on || codec->power_count || codec->power_transition) 3152 return; 3153 if (power_save(codec)) { 3154 codec->power_transition = 1; /* avoid reentrance */ 3155 queue_delayed_work(codec->bus->workq, &codec->power_work, 3156 msecs_to_jiffies(power_save(codec) * 1000)); 3157 } 3158 } 3159 EXPORT_SYMBOL_HDA(snd_hda_power_down); 3160 3161 int snd_hda_check_amp_list_power(struct hda_codec *codec, 3162 struct hda_loopback_check *check, 3163 hda_nid_t nid) 3164 { 3165 struct hda_amp_list *p; 3166 int ch, v; 3167 3168 if (!check->amplist) 3169 return 0; 3170 for (p = check->amplist; p->nid; p++) { 3171 if (p->nid == nid) 3172 break; 3173 } 3174 if (!p->nid) 3175 return 0; /* nothing changed */ 3176 3177 for (p = check->amplist; p->nid; p++) { 3178 for (ch = 0; ch < 2; ch++) { 3179 v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir, 3180 p->idx); 3181 if (!(v & HDA_AMP_MUTE) && v > 0) { 3182 if (!check->power_on) { 3183 check->power_on = 1; 3184 snd_hda_power_up(codec); 3185 } 3186 return 1; 3187 } 3188 } 3189 } 3190 if (check->power_on) { 3191 check->power_on = 0; 3192 snd_hda_power_down(codec); 3193 } 3194 return 0; 3195 } 3196 EXPORT_SYMBOL_HDA(snd_hda_check_amp_list_power); 3197 #endif 3198 3199 /* 3200 * Channel mode helper 3201 */ 3202 int snd_hda_ch_mode_info(struct hda_codec *codec, 3203 struct snd_ctl_elem_info *uinfo, 3204 const struct hda_channel_mode *chmode, 3205 int num_chmodes) 3206 { 3207 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 3208 uinfo->count = 1; 3209 uinfo->value.enumerated.items = num_chmodes; 3210 if (uinfo->value.enumerated.item >= num_chmodes) 3211 uinfo->value.enumerated.item = num_chmodes - 1; 3212 sprintf(uinfo->value.enumerated.name, "%dch", 3213 chmode[uinfo->value.enumerated.item].channels); 3214 return 0; 3215 } 3216 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info); 3217 3218 int snd_hda_ch_mode_get(struct hda_codec *codec, 3219 struct snd_ctl_elem_value *ucontrol, 3220 const struct hda_channel_mode *chmode, 3221 int num_chmodes, 3222 int max_channels) 3223 { 3224 int i; 3225 3226 for (i = 0; i < num_chmodes; i++) { 3227 if (max_channels == chmode[i].channels) { 3228 ucontrol->value.enumerated.item[0] = i; 3229 break; 3230 } 3231 } 3232 return 0; 3233 } 3234 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get); 3235 3236 int snd_hda_ch_mode_put(struct hda_codec *codec, 3237 struct snd_ctl_elem_value *ucontrol, 3238 const struct hda_channel_mode *chmode, 3239 int num_chmodes, 3240 int *max_channelsp) 3241 { 3242 unsigned int mode; 3243 3244 mode = ucontrol->value.enumerated.item[0]; 3245 if (mode >= num_chmodes) 3246 return -EINVAL; 3247 if (*max_channelsp == chmode[mode].channels) 3248 return 0; 3249 /* change the current channel setting */ 3250 *max_channelsp = chmode[mode].channels; 3251 if (chmode[mode].sequence) 3252 snd_hda_sequence_write_cache(codec, chmode[mode].sequence); 3253 return 1; 3254 } 3255 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_put); 3256 3257 /* 3258 * input MUX helper 3259 */ 3260 int snd_hda_input_mux_info(const struct hda_input_mux *imux, 3261 struct snd_ctl_elem_info *uinfo) 3262 { 3263 unsigned int index; 3264 3265 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 3266 uinfo->count = 1; 3267 uinfo->value.enumerated.items = imux->num_items; 3268 if (!imux->num_items) 3269 return 0; 3270 index = uinfo->value.enumerated.item; 3271 if (index >= imux->num_items) 3272 index = imux->num_items - 1; 3273 strcpy(uinfo->value.enumerated.name, imux->items[index].label); 3274 return 0; 3275 } 3276 EXPORT_SYMBOL_HDA(snd_hda_input_mux_info); 3277 3278 int snd_hda_input_mux_put(struct hda_codec *codec, 3279 const struct hda_input_mux *imux, 3280 struct snd_ctl_elem_value *ucontrol, 3281 hda_nid_t nid, 3282 unsigned int *cur_val) 3283 { 3284 unsigned int idx; 3285 3286 if (!imux->num_items) 3287 return 0; 3288 idx = ucontrol->value.enumerated.item[0]; 3289 if (idx >= imux->num_items) 3290 idx = imux->num_items - 1; 3291 if (*cur_val == idx) 3292 return 0; 3293 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, 3294 imux->items[idx].index); 3295 *cur_val = idx; 3296 return 1; 3297 } 3298 EXPORT_SYMBOL_HDA(snd_hda_input_mux_put); 3299 3300 3301 /* 3302 * Multi-channel / digital-out PCM helper functions 3303 */ 3304 3305 /* setup SPDIF output stream */ 3306 static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid, 3307 unsigned int stream_tag, unsigned int format) 3308 { 3309 /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */ 3310 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE)) 3311 set_dig_out_convert(codec, nid, 3312 codec->spdif_ctls & ~AC_DIG1_ENABLE & 0xff, 3313 -1); 3314 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format); 3315 if (codec->slave_dig_outs) { 3316 hda_nid_t *d; 3317 for (d = codec->slave_dig_outs; *d; d++) 3318 snd_hda_codec_setup_stream(codec, *d, stream_tag, 0, 3319 format); 3320 } 3321 /* turn on again (if needed) */ 3322 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE)) 3323 set_dig_out_convert(codec, nid, 3324 codec->spdif_ctls & 0xff, -1); 3325 } 3326 3327 static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid) 3328 { 3329 snd_hda_codec_cleanup_stream(codec, nid); 3330 if (codec->slave_dig_outs) { 3331 hda_nid_t *d; 3332 for (d = codec->slave_dig_outs; *d; d++) 3333 snd_hda_codec_cleanup_stream(codec, *d); 3334 } 3335 } 3336 3337 /* 3338 * open the digital out in the exclusive mode 3339 */ 3340 int snd_hda_multi_out_dig_open(struct hda_codec *codec, 3341 struct hda_multi_out *mout) 3342 { 3343 mutex_lock(&codec->spdif_mutex); 3344 if (mout->dig_out_used == HDA_DIG_ANALOG_DUP) 3345 /* already opened as analog dup; reset it once */ 3346 cleanup_dig_out_stream(codec, mout->dig_out_nid); 3347 mout->dig_out_used = HDA_DIG_EXCLUSIVE; 3348 mutex_unlock(&codec->spdif_mutex); 3349 return 0; 3350 } 3351 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_open); 3352 3353 int snd_hda_multi_out_dig_prepare(struct hda_codec *codec, 3354 struct hda_multi_out *mout, 3355 unsigned int stream_tag, 3356 unsigned int format, 3357 struct snd_pcm_substream *substream) 3358 { 3359 mutex_lock(&codec->spdif_mutex); 3360 setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format); 3361 mutex_unlock(&codec->spdif_mutex); 3362 return 0; 3363 } 3364 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare); 3365 3366 int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec, 3367 struct hda_multi_out *mout) 3368 { 3369 mutex_lock(&codec->spdif_mutex); 3370 cleanup_dig_out_stream(codec, mout->dig_out_nid); 3371 mutex_unlock(&codec->spdif_mutex); 3372 return 0; 3373 } 3374 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_cleanup); 3375 3376 /* 3377 * release the digital out 3378 */ 3379 int snd_hda_multi_out_dig_close(struct hda_codec *codec, 3380 struct hda_multi_out *mout) 3381 { 3382 mutex_lock(&codec->spdif_mutex); 3383 mout->dig_out_used = 0; 3384 mutex_unlock(&codec->spdif_mutex); 3385 return 0; 3386 } 3387 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_close); 3388 3389 /* 3390 * set up more restrictions for analog out 3391 */ 3392 int snd_hda_multi_out_analog_open(struct hda_codec *codec, 3393 struct hda_multi_out *mout, 3394 struct snd_pcm_substream *substream, 3395 struct hda_pcm_stream *hinfo) 3396 { 3397 struct snd_pcm_runtime *runtime = substream->runtime; 3398 runtime->hw.channels_max = mout->max_channels; 3399 if (mout->dig_out_nid) { 3400 if (!mout->analog_rates) { 3401 mout->analog_rates = hinfo->rates; 3402 mout->analog_formats = hinfo->formats; 3403 mout->analog_maxbps = hinfo->maxbps; 3404 } else { 3405 runtime->hw.rates = mout->analog_rates; 3406 runtime->hw.formats = mout->analog_formats; 3407 hinfo->maxbps = mout->analog_maxbps; 3408 } 3409 if (!mout->spdif_rates) { 3410 snd_hda_query_supported_pcm(codec, mout->dig_out_nid, 3411 &mout->spdif_rates, 3412 &mout->spdif_formats, 3413 &mout->spdif_maxbps); 3414 } 3415 mutex_lock(&codec->spdif_mutex); 3416 if (mout->share_spdif) { 3417 runtime->hw.rates &= mout->spdif_rates; 3418 runtime->hw.formats &= mout->spdif_formats; 3419 if (mout->spdif_maxbps < hinfo->maxbps) 3420 hinfo->maxbps = mout->spdif_maxbps; 3421 } 3422 mutex_unlock(&codec->spdif_mutex); 3423 } 3424 return snd_pcm_hw_constraint_step(substream->runtime, 0, 3425 SNDRV_PCM_HW_PARAM_CHANNELS, 2); 3426 } 3427 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_open); 3428 3429 /* 3430 * set up the i/o for analog out 3431 * when the digital out is available, copy the front out to digital out, too. 3432 */ 3433 int snd_hda_multi_out_analog_prepare(struct hda_codec *codec, 3434 struct hda_multi_out *mout, 3435 unsigned int stream_tag, 3436 unsigned int format, 3437 struct snd_pcm_substream *substream) 3438 { 3439 hda_nid_t *nids = mout->dac_nids; 3440 int chs = substream->runtime->channels; 3441 int i; 3442 3443 mutex_lock(&codec->spdif_mutex); 3444 if (mout->dig_out_nid && mout->share_spdif && 3445 mout->dig_out_used != HDA_DIG_EXCLUSIVE) { 3446 if (chs == 2 && 3447 snd_hda_is_supported_format(codec, mout->dig_out_nid, 3448 format) && 3449 !(codec->spdif_status & IEC958_AES0_NONAUDIO)) { 3450 mout->dig_out_used = HDA_DIG_ANALOG_DUP; 3451 setup_dig_out_stream(codec, mout->dig_out_nid, 3452 stream_tag, format); 3453 } else { 3454 mout->dig_out_used = 0; 3455 cleanup_dig_out_stream(codec, mout->dig_out_nid); 3456 } 3457 } 3458 mutex_unlock(&codec->spdif_mutex); 3459 3460 /* front */ 3461 snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag, 3462 0, format); 3463 if (!mout->no_share_stream && 3464 mout->hp_nid && mout->hp_nid != nids[HDA_FRONT]) 3465 /* headphone out will just decode front left/right (stereo) */ 3466 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag, 3467 0, format); 3468 /* extra outputs copied from front */ 3469 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++) 3470 if (!mout->no_share_stream && mout->extra_out_nid[i]) 3471 snd_hda_codec_setup_stream(codec, 3472 mout->extra_out_nid[i], 3473 stream_tag, 0, format); 3474 3475 /* surrounds */ 3476 for (i = 1; i < mout->num_dacs; i++) { 3477 if (chs >= (i + 1) * 2) /* independent out */ 3478 snd_hda_codec_setup_stream(codec, nids[i], stream_tag, 3479 i * 2, format); 3480 else if (!mout->no_share_stream) /* copy front */ 3481 snd_hda_codec_setup_stream(codec, nids[i], stream_tag, 3482 0, format); 3483 } 3484 return 0; 3485 } 3486 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_prepare); 3487 3488 /* 3489 * clean up the setting for analog out 3490 */ 3491 int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec, 3492 struct hda_multi_out *mout) 3493 { 3494 hda_nid_t *nids = mout->dac_nids; 3495 int i; 3496 3497 for (i = 0; i < mout->num_dacs; i++) 3498 snd_hda_codec_cleanup_stream(codec, nids[i]); 3499 if (mout->hp_nid) 3500 snd_hda_codec_cleanup_stream(codec, mout->hp_nid); 3501 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++) 3502 if (mout->extra_out_nid[i]) 3503 snd_hda_codec_cleanup_stream(codec, 3504 mout->extra_out_nid[i]); 3505 mutex_lock(&codec->spdif_mutex); 3506 if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) { 3507 cleanup_dig_out_stream(codec, mout->dig_out_nid); 3508 mout->dig_out_used = 0; 3509 } 3510 mutex_unlock(&codec->spdif_mutex); 3511 return 0; 3512 } 3513 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_cleanup); 3514 3515 /* 3516 * Helper for automatic pin configuration 3517 */ 3518 3519 static int is_in_nid_list(hda_nid_t nid, hda_nid_t *list) 3520 { 3521 for (; *list; list++) 3522 if (*list == nid) 3523 return 1; 3524 return 0; 3525 } 3526 3527 3528 /* 3529 * Sort an associated group of pins according to their sequence numbers. 3530 */ 3531 static void sort_pins_by_sequence(hda_nid_t * pins, short * sequences, 3532 int num_pins) 3533 { 3534 int i, j; 3535 short seq; 3536 hda_nid_t nid; 3537 3538 for (i = 0; i < num_pins; i++) { 3539 for (j = i + 1; j < num_pins; j++) { 3540 if (sequences[i] > sequences[j]) { 3541 seq = sequences[i]; 3542 sequences[i] = sequences[j]; 3543 sequences[j] = seq; 3544 nid = pins[i]; 3545 pins[i] = pins[j]; 3546 pins[j] = nid; 3547 } 3548 } 3549 } 3550 } 3551 3552 3553 /* 3554 * Parse all pin widgets and store the useful pin nids to cfg 3555 * 3556 * The number of line-outs or any primary output is stored in line_outs, 3557 * and the corresponding output pins are assigned to line_out_pins[], 3558 * in the order of front, rear, CLFE, side, ... 3559 * 3560 * If more extra outputs (speaker and headphone) are found, the pins are 3561 * assisnged to hp_pins[] and speaker_pins[], respectively. If no line-out jack 3562 * is detected, one of speaker of HP pins is assigned as the primary 3563 * output, i.e. to line_out_pins[0]. So, line_outs is always positive 3564 * if any analog output exists. 3565 * 3566 * The analog input pins are assigned to input_pins array. 3567 * The digital input/output pins are assigned to dig_in_pin and dig_out_pin, 3568 * respectively. 3569 */ 3570 int snd_hda_parse_pin_def_config(struct hda_codec *codec, 3571 struct auto_pin_cfg *cfg, 3572 hda_nid_t *ignore_nids) 3573 { 3574 hda_nid_t nid, end_nid; 3575 short seq, assoc_line_out, assoc_speaker; 3576 short sequences_line_out[ARRAY_SIZE(cfg->line_out_pins)]; 3577 short sequences_speaker[ARRAY_SIZE(cfg->speaker_pins)]; 3578 short sequences_hp[ARRAY_SIZE(cfg->hp_pins)]; 3579 3580 memset(cfg, 0, sizeof(*cfg)); 3581 3582 memset(sequences_line_out, 0, sizeof(sequences_line_out)); 3583 memset(sequences_speaker, 0, sizeof(sequences_speaker)); 3584 memset(sequences_hp, 0, sizeof(sequences_hp)); 3585 assoc_line_out = assoc_speaker = 0; 3586 3587 end_nid = codec->start_nid + codec->num_nodes; 3588 for (nid = codec->start_nid; nid < end_nid; nid++) { 3589 unsigned int wid_caps = get_wcaps(codec, nid); 3590 unsigned int wid_type = 3591 (wid_caps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT; 3592 unsigned int def_conf; 3593 short assoc, loc; 3594 3595 /* read all default configuration for pin complex */ 3596 if (wid_type != AC_WID_PIN) 3597 continue; 3598 /* ignore the given nids (e.g. pc-beep returns error) */ 3599 if (ignore_nids && is_in_nid_list(nid, ignore_nids)) 3600 continue; 3601 3602 def_conf = snd_hda_codec_get_pincfg(codec, nid); 3603 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE) 3604 continue; 3605 loc = get_defcfg_location(def_conf); 3606 switch (get_defcfg_device(def_conf)) { 3607 case AC_JACK_LINE_OUT: 3608 seq = get_defcfg_sequence(def_conf); 3609 assoc = get_defcfg_association(def_conf); 3610 3611 if (!(wid_caps & AC_WCAP_STEREO)) 3612 if (!cfg->mono_out_pin) 3613 cfg->mono_out_pin = nid; 3614 if (!assoc) 3615 continue; 3616 if (!assoc_line_out) 3617 assoc_line_out = assoc; 3618 else if (assoc_line_out != assoc) 3619 continue; 3620 if (cfg->line_outs >= ARRAY_SIZE(cfg->line_out_pins)) 3621 continue; 3622 cfg->line_out_pins[cfg->line_outs] = nid; 3623 sequences_line_out[cfg->line_outs] = seq; 3624 cfg->line_outs++; 3625 break; 3626 case AC_JACK_SPEAKER: 3627 seq = get_defcfg_sequence(def_conf); 3628 assoc = get_defcfg_association(def_conf); 3629 if (! assoc) 3630 continue; 3631 if (! assoc_speaker) 3632 assoc_speaker = assoc; 3633 else if (assoc_speaker != assoc) 3634 continue; 3635 if (cfg->speaker_outs >= ARRAY_SIZE(cfg->speaker_pins)) 3636 continue; 3637 cfg->speaker_pins[cfg->speaker_outs] = nid; 3638 sequences_speaker[cfg->speaker_outs] = seq; 3639 cfg->speaker_outs++; 3640 break; 3641 case AC_JACK_HP_OUT: 3642 seq = get_defcfg_sequence(def_conf); 3643 assoc = get_defcfg_association(def_conf); 3644 if (cfg->hp_outs >= ARRAY_SIZE(cfg->hp_pins)) 3645 continue; 3646 cfg->hp_pins[cfg->hp_outs] = nid; 3647 sequences_hp[cfg->hp_outs] = (assoc << 4) | seq; 3648 cfg->hp_outs++; 3649 break; 3650 case AC_JACK_MIC_IN: { 3651 int preferred, alt; 3652 if (loc == AC_JACK_LOC_FRONT) { 3653 preferred = AUTO_PIN_FRONT_MIC; 3654 alt = AUTO_PIN_MIC; 3655 } else { 3656 preferred = AUTO_PIN_MIC; 3657 alt = AUTO_PIN_FRONT_MIC; 3658 } 3659 if (!cfg->input_pins[preferred]) 3660 cfg->input_pins[preferred] = nid; 3661 else if (!cfg->input_pins[alt]) 3662 cfg->input_pins[alt] = nid; 3663 break; 3664 } 3665 case AC_JACK_LINE_IN: 3666 if (loc == AC_JACK_LOC_FRONT) 3667 cfg->input_pins[AUTO_PIN_FRONT_LINE] = nid; 3668 else 3669 cfg->input_pins[AUTO_PIN_LINE] = nid; 3670 break; 3671 case AC_JACK_CD: 3672 cfg->input_pins[AUTO_PIN_CD] = nid; 3673 break; 3674 case AC_JACK_AUX: 3675 cfg->input_pins[AUTO_PIN_AUX] = nid; 3676 break; 3677 case AC_JACK_SPDIF_OUT: 3678 case AC_JACK_DIG_OTHER_OUT: 3679 if (cfg->dig_outs >= ARRAY_SIZE(cfg->dig_out_pins)) 3680 continue; 3681 cfg->dig_out_pins[cfg->dig_outs] = nid; 3682 cfg->dig_out_type[cfg->dig_outs] = 3683 (loc == AC_JACK_LOC_HDMI) ? 3684 HDA_PCM_TYPE_HDMI : HDA_PCM_TYPE_SPDIF; 3685 cfg->dig_outs++; 3686 break; 3687 case AC_JACK_SPDIF_IN: 3688 case AC_JACK_DIG_OTHER_IN: 3689 cfg->dig_in_pin = nid; 3690 if (loc == AC_JACK_LOC_HDMI) 3691 cfg->dig_in_type = HDA_PCM_TYPE_HDMI; 3692 else 3693 cfg->dig_in_type = HDA_PCM_TYPE_SPDIF; 3694 break; 3695 } 3696 } 3697 3698 /* FIX-UP: 3699 * If no line-out is defined but multiple HPs are found, 3700 * some of them might be the real line-outs. 3701 */ 3702 if (!cfg->line_outs && cfg->hp_outs > 1) { 3703 int i = 0; 3704 while (i < cfg->hp_outs) { 3705 /* The real HPs should have the sequence 0x0f */ 3706 if ((sequences_hp[i] & 0x0f) == 0x0f) { 3707 i++; 3708 continue; 3709 } 3710 /* Move it to the line-out table */ 3711 cfg->line_out_pins[cfg->line_outs] = cfg->hp_pins[i]; 3712 sequences_line_out[cfg->line_outs] = sequences_hp[i]; 3713 cfg->line_outs++; 3714 cfg->hp_outs--; 3715 memmove(cfg->hp_pins + i, cfg->hp_pins + i + 1, 3716 sizeof(cfg->hp_pins[0]) * (cfg->hp_outs - i)); 3717 memmove(sequences_hp + i - 1, sequences_hp + i, 3718 sizeof(sequences_hp[0]) * (cfg->hp_outs - i)); 3719 } 3720 } 3721 3722 /* sort by sequence */ 3723 sort_pins_by_sequence(cfg->line_out_pins, sequences_line_out, 3724 cfg->line_outs); 3725 sort_pins_by_sequence(cfg->speaker_pins, sequences_speaker, 3726 cfg->speaker_outs); 3727 sort_pins_by_sequence(cfg->hp_pins, sequences_hp, 3728 cfg->hp_outs); 3729 3730 /* if we have only one mic, make it AUTO_PIN_MIC */ 3731 if (!cfg->input_pins[AUTO_PIN_MIC] && 3732 cfg->input_pins[AUTO_PIN_FRONT_MIC]) { 3733 cfg->input_pins[AUTO_PIN_MIC] = 3734 cfg->input_pins[AUTO_PIN_FRONT_MIC]; 3735 cfg->input_pins[AUTO_PIN_FRONT_MIC] = 0; 3736 } 3737 /* ditto for line-in */ 3738 if (!cfg->input_pins[AUTO_PIN_LINE] && 3739 cfg->input_pins[AUTO_PIN_FRONT_LINE]) { 3740 cfg->input_pins[AUTO_PIN_LINE] = 3741 cfg->input_pins[AUTO_PIN_FRONT_LINE]; 3742 cfg->input_pins[AUTO_PIN_FRONT_LINE] = 0; 3743 } 3744 3745 /* 3746 * FIX-UP: if no line-outs are detected, try to use speaker or HP pin 3747 * as a primary output 3748 */ 3749 if (!cfg->line_outs) { 3750 if (cfg->speaker_outs) { 3751 cfg->line_outs = cfg->speaker_outs; 3752 memcpy(cfg->line_out_pins, cfg->speaker_pins, 3753 sizeof(cfg->speaker_pins)); 3754 cfg->speaker_outs = 0; 3755 memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins)); 3756 cfg->line_out_type = AUTO_PIN_SPEAKER_OUT; 3757 } else if (cfg->hp_outs) { 3758 cfg->line_outs = cfg->hp_outs; 3759 memcpy(cfg->line_out_pins, cfg->hp_pins, 3760 sizeof(cfg->hp_pins)); 3761 cfg->hp_outs = 0; 3762 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins)); 3763 cfg->line_out_type = AUTO_PIN_HP_OUT; 3764 } 3765 } 3766 3767 /* Reorder the surround channels 3768 * ALSA sequence is front/surr/clfe/side 3769 * HDA sequence is: 3770 * 4-ch: front/surr => OK as it is 3771 * 6-ch: front/clfe/surr 3772 * 8-ch: front/clfe/rear/side|fc 3773 */ 3774 switch (cfg->line_outs) { 3775 case 3: 3776 case 4: 3777 nid = cfg->line_out_pins[1]; 3778 cfg->line_out_pins[1] = cfg->line_out_pins[2]; 3779 cfg->line_out_pins[2] = nid; 3780 break; 3781 } 3782 3783 /* 3784 * debug prints of the parsed results 3785 */ 3786 snd_printd("autoconfig: line_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n", 3787 cfg->line_outs, cfg->line_out_pins[0], cfg->line_out_pins[1], 3788 cfg->line_out_pins[2], cfg->line_out_pins[3], 3789 cfg->line_out_pins[4]); 3790 snd_printd(" speaker_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n", 3791 cfg->speaker_outs, cfg->speaker_pins[0], 3792 cfg->speaker_pins[1], cfg->speaker_pins[2], 3793 cfg->speaker_pins[3], cfg->speaker_pins[4]); 3794 snd_printd(" hp_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n", 3795 cfg->hp_outs, cfg->hp_pins[0], 3796 cfg->hp_pins[1], cfg->hp_pins[2], 3797 cfg->hp_pins[3], cfg->hp_pins[4]); 3798 snd_printd(" mono: mono_out=0x%x\n", cfg->mono_out_pin); 3799 if (cfg->dig_outs) 3800 snd_printd(" dig-out=0x%x/0x%x\n", 3801 cfg->dig_out_pins[0], cfg->dig_out_pins[1]); 3802 snd_printd(" inputs: mic=0x%x, fmic=0x%x, line=0x%x, fline=0x%x," 3803 " cd=0x%x, aux=0x%x\n", 3804 cfg->input_pins[AUTO_PIN_MIC], 3805 cfg->input_pins[AUTO_PIN_FRONT_MIC], 3806 cfg->input_pins[AUTO_PIN_LINE], 3807 cfg->input_pins[AUTO_PIN_FRONT_LINE], 3808 cfg->input_pins[AUTO_PIN_CD], 3809 cfg->input_pins[AUTO_PIN_AUX]); 3810 if (cfg->dig_in_pin) 3811 snd_printd(" dig-in=0x%x\n", cfg->dig_in_pin); 3812 3813 return 0; 3814 } 3815 EXPORT_SYMBOL_HDA(snd_hda_parse_pin_def_config); 3816 3817 /* labels for input pins */ 3818 const char *auto_pin_cfg_labels[AUTO_PIN_LAST] = { 3819 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux" 3820 }; 3821 EXPORT_SYMBOL_HDA(auto_pin_cfg_labels); 3822 3823 3824 #ifdef CONFIG_PM 3825 /* 3826 * power management 3827 */ 3828 3829 /** 3830 * snd_hda_suspend - suspend the codecs 3831 * @bus: the HDA bus 3832 * @state: suspsend state 3833 * 3834 * Returns 0 if successful. 3835 */ 3836 int snd_hda_suspend(struct hda_bus *bus, pm_message_t state) 3837 { 3838 struct hda_codec *codec; 3839 3840 list_for_each_entry(codec, &bus->codec_list, list) { 3841 #ifdef CONFIG_SND_HDA_POWER_SAVE 3842 if (!codec->power_on) 3843 continue; 3844 #endif 3845 hda_call_codec_suspend(codec); 3846 } 3847 return 0; 3848 } 3849 EXPORT_SYMBOL_HDA(snd_hda_suspend); 3850 3851 /** 3852 * snd_hda_resume - resume the codecs 3853 * @bus: the HDA bus 3854 * 3855 * Returns 0 if successful. 3856 * 3857 * This fucntion is defined only when POWER_SAVE isn't set. 3858 * In the power-save mode, the codec is resumed dynamically. 3859 */ 3860 int snd_hda_resume(struct hda_bus *bus) 3861 { 3862 struct hda_codec *codec; 3863 3864 list_for_each_entry(codec, &bus->codec_list, list) { 3865 if (snd_hda_codec_needs_resume(codec)) 3866 hda_call_codec_resume(codec); 3867 } 3868 return 0; 3869 } 3870 EXPORT_SYMBOL_HDA(snd_hda_resume); 3871 #endif /* CONFIG_PM */ 3872 3873 /* 3874 * generic arrays 3875 */ 3876 3877 /* get a new element from the given array 3878 * if it exceeds the pre-allocated array size, re-allocate the array 3879 */ 3880 void *snd_array_new(struct snd_array *array) 3881 { 3882 if (array->used >= array->alloced) { 3883 int num = array->alloced + array->alloc_align; 3884 void *nlist; 3885 if (snd_BUG_ON(num >= 4096)) 3886 return NULL; 3887 nlist = kcalloc(num + 1, array->elem_size, GFP_KERNEL); 3888 if (!nlist) 3889 return NULL; 3890 if (array->list) { 3891 memcpy(nlist, array->list, 3892 array->elem_size * array->alloced); 3893 kfree(array->list); 3894 } 3895 array->list = nlist; 3896 array->alloced = num; 3897 } 3898 return snd_array_elem(array, array->used++); 3899 } 3900 EXPORT_SYMBOL_HDA(snd_array_new); 3901 3902 /* free the given array elements */ 3903 void snd_array_free(struct snd_array *array) 3904 { 3905 kfree(array->list); 3906 array->used = 0; 3907 array->alloced = 0; 3908 array->list = NULL; 3909 } 3910 EXPORT_SYMBOL_HDA(snd_array_free); 3911 3912 /* 3913 * used by hda_proc.c and hda_eld.c 3914 */ 3915 void snd_print_pcm_rates(int pcm, char *buf, int buflen) 3916 { 3917 static unsigned int rates[] = { 3918 8000, 11025, 16000, 22050, 32000, 44100, 48000, 88200, 3919 96000, 176400, 192000, 384000 3920 }; 3921 int i, j; 3922 3923 for (i = 0, j = 0; i < ARRAY_SIZE(rates); i++) 3924 if (pcm & (1 << i)) 3925 j += snprintf(buf + j, buflen - j, " %d", rates[i]); 3926 3927 buf[j] = '\0'; /* necessary when j == 0 */ 3928 } 3929 EXPORT_SYMBOL_HDA(snd_print_pcm_rates); 3930 3931 void snd_print_pcm_bits(int pcm, char *buf, int buflen) 3932 { 3933 static unsigned int bits[] = { 8, 16, 20, 24, 32 }; 3934 int i, j; 3935 3936 for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++) 3937 if (pcm & (AC_SUPPCM_BITS_8 << i)) 3938 j += snprintf(buf + j, buflen - j, " %d", bits[i]); 3939 3940 buf[j] = '\0'; /* necessary when j == 0 */ 3941 } 3942 EXPORT_SYMBOL_HDA(snd_print_pcm_bits); 3943 3944 MODULE_DESCRIPTION("HDA codec core"); 3945 MODULE_LICENSE("GPL"); 3946