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/mm.h> 23 #include <linux/init.h> 24 #include <linux/delay.h> 25 #include <linux/slab.h> 26 #include <linux/mutex.h> 27 #include <linux/module.h> 28 #include <linux/async.h> 29 #include <linux/pm.h> 30 #include <linux/pm_runtime.h> 31 #include <sound/core.h> 32 #include "hda_codec.h" 33 #include <sound/asoundef.h> 34 #include <sound/tlv.h> 35 #include <sound/initval.h> 36 #include <sound/jack.h> 37 #include "hda_local.h" 38 #include "hda_beep.h" 39 #include "hda_jack.h" 40 #include <sound/hda_hwdep.h> 41 42 #ifdef CONFIG_PM 43 #define codec_in_pm(codec) atomic_read(&(codec)->core.in_pm) 44 #define hda_codec_is_power_on(codec) \ 45 (!pm_runtime_suspended(hda_codec_dev(codec))) 46 #else 47 #define codec_in_pm(codec) 0 48 #define hda_codec_is_power_on(codec) 1 49 #endif 50 51 #define codec_has_epss(codec) \ 52 ((codec)->core.power_caps & AC_PWRST_EPSS) 53 #define codec_has_clkstop(codec) \ 54 ((codec)->core.power_caps & AC_PWRST_CLKSTOP) 55 56 /** 57 * snd_hda_get_jack_location - Give a location string of the jack 58 * @cfg: pin default config value 59 * 60 * Parse the pin default config value and returns the string of the 61 * jack location, e.g. "Rear", "Front", etc. 62 */ 63 const char *snd_hda_get_jack_location(u32 cfg) 64 { 65 static char *bases[7] = { 66 "N/A", "Rear", "Front", "Left", "Right", "Top", "Bottom", 67 }; 68 static unsigned char specials_idx[] = { 69 0x07, 0x08, 70 0x17, 0x18, 0x19, 71 0x37, 0x38 72 }; 73 static char *specials[] = { 74 "Rear Panel", "Drive Bar", 75 "Riser", "HDMI", "ATAPI", 76 "Mobile-In", "Mobile-Out" 77 }; 78 int i; 79 cfg = (cfg & AC_DEFCFG_LOCATION) >> AC_DEFCFG_LOCATION_SHIFT; 80 if ((cfg & 0x0f) < 7) 81 return bases[cfg & 0x0f]; 82 for (i = 0; i < ARRAY_SIZE(specials_idx); i++) { 83 if (cfg == specials_idx[i]) 84 return specials[i]; 85 } 86 return "UNKNOWN"; 87 } 88 EXPORT_SYMBOL_GPL(snd_hda_get_jack_location); 89 90 /** 91 * snd_hda_get_jack_connectivity - Give a connectivity string of the jack 92 * @cfg: pin default config value 93 * 94 * Parse the pin default config value and returns the string of the 95 * jack connectivity, i.e. external or internal connection. 96 */ 97 const char *snd_hda_get_jack_connectivity(u32 cfg) 98 { 99 static char *jack_locations[4] = { "Ext", "Int", "Sep", "Oth" }; 100 101 return jack_locations[(cfg >> (AC_DEFCFG_LOCATION_SHIFT + 4)) & 3]; 102 } 103 EXPORT_SYMBOL_GPL(snd_hda_get_jack_connectivity); 104 105 /** 106 * snd_hda_get_jack_type - Give a type string of the jack 107 * @cfg: pin default config value 108 * 109 * Parse the pin default config value and returns the string of the 110 * jack type, i.e. the purpose of the jack, such as Line-Out or CD. 111 */ 112 const char *snd_hda_get_jack_type(u32 cfg) 113 { 114 static char *jack_types[16] = { 115 "Line Out", "Speaker", "HP Out", "CD", 116 "SPDIF Out", "Digital Out", "Modem Line", "Modem Hand", 117 "Line In", "Aux", "Mic", "Telephony", 118 "SPDIF In", "Digital In", "Reserved", "Other" 119 }; 120 121 return jack_types[(cfg & AC_DEFCFG_DEVICE) 122 >> AC_DEFCFG_DEVICE_SHIFT]; 123 } 124 EXPORT_SYMBOL_GPL(snd_hda_get_jack_type); 125 126 /* 127 * Send and receive a verb - passed to exec_verb override for hdac_device 128 */ 129 static int codec_exec_verb(struct hdac_device *dev, unsigned int cmd, 130 unsigned int flags, unsigned int *res) 131 { 132 struct hda_codec *codec = container_of(dev, struct hda_codec, core); 133 struct hda_bus *bus = codec->bus; 134 int err; 135 136 if (cmd == ~0) 137 return -1; 138 139 again: 140 snd_hda_power_up_pm(codec); 141 mutex_lock(&bus->core.cmd_mutex); 142 if (flags & HDA_RW_NO_RESPONSE_FALLBACK) 143 bus->no_response_fallback = 1; 144 err = snd_hdac_bus_exec_verb_unlocked(&bus->core, codec->core.addr, 145 cmd, res); 146 bus->no_response_fallback = 0; 147 mutex_unlock(&bus->core.cmd_mutex); 148 snd_hda_power_down_pm(codec); 149 if (!codec_in_pm(codec) && res && err < 0 && bus->rirb_error) { 150 if (bus->response_reset) { 151 codec_dbg(codec, 152 "resetting BUS due to fatal communication error\n"); 153 bus->ops.bus_reset(bus); 154 } 155 goto again; 156 } 157 /* clear reset-flag when the communication gets recovered */ 158 if (!err || codec_in_pm(codec)) 159 bus->response_reset = 0; 160 return err; 161 } 162 163 /** 164 * snd_hda_codec_read - send a command and get the response 165 * @codec: the HDA codec 166 * @nid: NID to send the command 167 * @flags: optional bit flags 168 * @verb: the verb to send 169 * @parm: the parameter for the verb 170 * 171 * Send a single command and read the corresponding response. 172 * 173 * Returns the obtained response value, or -1 for an error. 174 */ 175 unsigned int snd_hda_codec_read(struct hda_codec *codec, hda_nid_t nid, 176 int flags, 177 unsigned int verb, unsigned int parm) 178 { 179 unsigned int cmd = snd_hdac_make_cmd(&codec->core, nid, verb, parm); 180 unsigned int res; 181 if (snd_hdac_exec_verb(&codec->core, cmd, flags, &res)) 182 return -1; 183 return res; 184 } 185 EXPORT_SYMBOL_GPL(snd_hda_codec_read); 186 187 /** 188 * snd_hda_codec_write - send a single command without waiting for response 189 * @codec: the HDA codec 190 * @nid: NID to send the command 191 * @flags: optional bit flags 192 * @verb: the verb to send 193 * @parm: the parameter for the verb 194 * 195 * Send a single command without waiting for response. 196 * 197 * Returns 0 if successful, or a negative error code. 198 */ 199 int snd_hda_codec_write(struct hda_codec *codec, hda_nid_t nid, int flags, 200 unsigned int verb, unsigned int parm) 201 { 202 unsigned int cmd = snd_hdac_make_cmd(&codec->core, nid, verb, parm); 203 return snd_hdac_exec_verb(&codec->core, cmd, flags, NULL); 204 } 205 EXPORT_SYMBOL_GPL(snd_hda_codec_write); 206 207 /** 208 * snd_hda_sequence_write - sequence writes 209 * @codec: the HDA codec 210 * @seq: VERB array to send 211 * 212 * Send the commands sequentially from the given array. 213 * The array must be terminated with NID=0. 214 */ 215 void snd_hda_sequence_write(struct hda_codec *codec, const struct hda_verb *seq) 216 { 217 for (; seq->nid; seq++) 218 snd_hda_codec_write(codec, seq->nid, 0, seq->verb, seq->param); 219 } 220 EXPORT_SYMBOL_GPL(snd_hda_sequence_write); 221 222 /* connection list element */ 223 struct hda_conn_list { 224 struct list_head list; 225 int len; 226 hda_nid_t nid; 227 hda_nid_t conns[0]; 228 }; 229 230 /* look up the cached results */ 231 static struct hda_conn_list * 232 lookup_conn_list(struct hda_codec *codec, hda_nid_t nid) 233 { 234 struct hda_conn_list *p; 235 list_for_each_entry(p, &codec->conn_list, list) { 236 if (p->nid == nid) 237 return p; 238 } 239 return NULL; 240 } 241 242 static int add_conn_list(struct hda_codec *codec, hda_nid_t nid, int len, 243 const hda_nid_t *list) 244 { 245 struct hda_conn_list *p; 246 247 p = kmalloc(sizeof(*p) + len * sizeof(hda_nid_t), GFP_KERNEL); 248 if (!p) 249 return -ENOMEM; 250 p->len = len; 251 p->nid = nid; 252 memcpy(p->conns, list, len * sizeof(hda_nid_t)); 253 list_add(&p->list, &codec->conn_list); 254 return 0; 255 } 256 257 static void remove_conn_list(struct hda_codec *codec) 258 { 259 while (!list_empty(&codec->conn_list)) { 260 struct hda_conn_list *p; 261 p = list_first_entry(&codec->conn_list, typeof(*p), list); 262 list_del(&p->list); 263 kfree(p); 264 } 265 } 266 267 /* read the connection and add to the cache */ 268 static int read_and_add_raw_conns(struct hda_codec *codec, hda_nid_t nid) 269 { 270 hda_nid_t list[32]; 271 hda_nid_t *result = list; 272 int len; 273 274 len = snd_hda_get_raw_connections(codec, nid, list, ARRAY_SIZE(list)); 275 if (len == -ENOSPC) { 276 len = snd_hda_get_num_raw_conns(codec, nid); 277 result = kmalloc(sizeof(hda_nid_t) * len, GFP_KERNEL); 278 if (!result) 279 return -ENOMEM; 280 len = snd_hda_get_raw_connections(codec, nid, result, len); 281 } 282 if (len >= 0) 283 len = snd_hda_override_conn_list(codec, nid, len, result); 284 if (result != list) 285 kfree(result); 286 return len; 287 } 288 289 /** 290 * snd_hda_get_conn_list - get connection list 291 * @codec: the HDA codec 292 * @nid: NID to parse 293 * @listp: the pointer to store NID list 294 * 295 * Parses the connection list of the given widget and stores the pointer 296 * to the list of NIDs. 297 * 298 * Returns the number of connections, or a negative error code. 299 * 300 * Note that the returned pointer isn't protected against the list 301 * modification. If snd_hda_override_conn_list() might be called 302 * concurrently, protect with a mutex appropriately. 303 */ 304 int snd_hda_get_conn_list(struct hda_codec *codec, hda_nid_t nid, 305 const hda_nid_t **listp) 306 { 307 bool added = false; 308 309 for (;;) { 310 int err; 311 const struct hda_conn_list *p; 312 313 /* if the connection-list is already cached, read it */ 314 p = lookup_conn_list(codec, nid); 315 if (p) { 316 if (listp) 317 *listp = p->conns; 318 return p->len; 319 } 320 if (snd_BUG_ON(added)) 321 return -EINVAL; 322 323 err = read_and_add_raw_conns(codec, nid); 324 if (err < 0) 325 return err; 326 added = true; 327 } 328 } 329 EXPORT_SYMBOL_GPL(snd_hda_get_conn_list); 330 331 /** 332 * snd_hda_get_connections - copy connection list 333 * @codec: the HDA codec 334 * @nid: NID to parse 335 * @conn_list: connection list array; when NULL, checks only the size 336 * @max_conns: max. number of connections to store 337 * 338 * Parses the connection list of the given widget and stores the list 339 * of NIDs. 340 * 341 * Returns the number of connections, or a negative error code. 342 */ 343 int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid, 344 hda_nid_t *conn_list, int max_conns) 345 { 346 const hda_nid_t *list; 347 int len = snd_hda_get_conn_list(codec, nid, &list); 348 349 if (len > 0 && conn_list) { 350 if (len > max_conns) { 351 codec_err(codec, "Too many connections %d for NID 0x%x\n", 352 len, nid); 353 return -EINVAL; 354 } 355 memcpy(conn_list, list, len * sizeof(hda_nid_t)); 356 } 357 358 return len; 359 } 360 EXPORT_SYMBOL_GPL(snd_hda_get_connections); 361 362 /** 363 * snd_hda_override_conn_list - add/modify the connection-list to cache 364 * @codec: the HDA codec 365 * @nid: NID to parse 366 * @len: number of connection list entries 367 * @list: the list of connection entries 368 * 369 * Add or modify the given connection-list to the cache. If the corresponding 370 * cache already exists, invalidate it and append a new one. 371 * 372 * Returns zero or a negative error code. 373 */ 374 int snd_hda_override_conn_list(struct hda_codec *codec, hda_nid_t nid, int len, 375 const hda_nid_t *list) 376 { 377 struct hda_conn_list *p; 378 379 p = lookup_conn_list(codec, nid); 380 if (p) { 381 list_del(&p->list); 382 kfree(p); 383 } 384 385 return add_conn_list(codec, nid, len, list); 386 } 387 EXPORT_SYMBOL_GPL(snd_hda_override_conn_list); 388 389 /** 390 * snd_hda_get_conn_index - get the connection index of the given NID 391 * @codec: the HDA codec 392 * @mux: NID containing the list 393 * @nid: NID to select 394 * @recursive: 1 when searching NID recursively, otherwise 0 395 * 396 * Parses the connection list of the widget @mux and checks whether the 397 * widget @nid is present. If it is, return the connection index. 398 * Otherwise it returns -1. 399 */ 400 int snd_hda_get_conn_index(struct hda_codec *codec, hda_nid_t mux, 401 hda_nid_t nid, int recursive) 402 { 403 const hda_nid_t *conn; 404 int i, nums; 405 406 nums = snd_hda_get_conn_list(codec, mux, &conn); 407 for (i = 0; i < nums; i++) 408 if (conn[i] == nid) 409 return i; 410 if (!recursive) 411 return -1; 412 if (recursive > 10) { 413 codec_dbg(codec, "too deep connection for 0x%x\n", nid); 414 return -1; 415 } 416 recursive++; 417 for (i = 0; i < nums; i++) { 418 unsigned int type = get_wcaps_type(get_wcaps(codec, conn[i])); 419 if (type == AC_WID_PIN || type == AC_WID_AUD_OUT) 420 continue; 421 if (snd_hda_get_conn_index(codec, conn[i], nid, recursive) >= 0) 422 return i; 423 } 424 return -1; 425 } 426 EXPORT_SYMBOL_GPL(snd_hda_get_conn_index); 427 428 429 /* return DEVLIST_LEN parameter of the given widget */ 430 static unsigned int get_num_devices(struct hda_codec *codec, hda_nid_t nid) 431 { 432 unsigned int wcaps = get_wcaps(codec, nid); 433 unsigned int parm; 434 435 if (!codec->dp_mst || !(wcaps & AC_WCAP_DIGITAL) || 436 get_wcaps_type(wcaps) != AC_WID_PIN) 437 return 0; 438 439 parm = snd_hda_param_read(codec, nid, AC_PAR_DEVLIST_LEN); 440 if (parm == -1 && codec->bus->rirb_error) 441 parm = 0; 442 return parm & AC_DEV_LIST_LEN_MASK; 443 } 444 445 /** 446 * snd_hda_get_devices - copy device list without cache 447 * @codec: the HDA codec 448 * @nid: NID of the pin to parse 449 * @dev_list: device list array 450 * @max_devices: max. number of devices to store 451 * 452 * Copy the device list. This info is dynamic and so not cached. 453 * Currently called only from hda_proc.c, so not exported. 454 */ 455 int snd_hda_get_devices(struct hda_codec *codec, hda_nid_t nid, 456 u8 *dev_list, int max_devices) 457 { 458 unsigned int parm; 459 int i, dev_len, devices; 460 461 parm = get_num_devices(codec, nid); 462 if (!parm) /* not multi-stream capable */ 463 return 0; 464 465 dev_len = parm + 1; 466 dev_len = dev_len < max_devices ? dev_len : max_devices; 467 468 devices = 0; 469 while (devices < dev_len) { 470 parm = snd_hda_codec_read(codec, nid, 0, 471 AC_VERB_GET_DEVICE_LIST, devices); 472 if (parm == -1 && codec->bus->rirb_error) 473 break; 474 475 for (i = 0; i < 8; i++) { 476 dev_list[devices] = (u8)parm; 477 parm >>= 4; 478 devices++; 479 if (devices >= dev_len) 480 break; 481 } 482 } 483 return devices; 484 } 485 486 /* 487 * destructor 488 */ 489 static void snd_hda_bus_free(struct hda_bus *bus) 490 { 491 if (!bus) 492 return; 493 if (bus->ops.private_free) 494 bus->ops.private_free(bus); 495 snd_hdac_bus_exit(&bus->core); 496 kfree(bus); 497 } 498 499 static int snd_hda_bus_dev_free(struct snd_device *device) 500 { 501 snd_hda_bus_free(device->device_data); 502 return 0; 503 } 504 505 static int snd_hda_bus_dev_disconnect(struct snd_device *device) 506 { 507 struct hda_bus *bus = device->device_data; 508 bus->shutdown = 1; 509 return 0; 510 } 511 512 /* hdac_bus_ops translations */ 513 static int _hda_bus_command(struct hdac_bus *_bus, unsigned int cmd) 514 { 515 struct hda_bus *bus = container_of(_bus, struct hda_bus, core); 516 return bus->ops.command(bus, cmd); 517 } 518 519 static int _hda_bus_get_response(struct hdac_bus *_bus, unsigned int addr, 520 unsigned int *res) 521 { 522 struct hda_bus *bus = container_of(_bus, struct hda_bus, core); 523 *res = bus->ops.get_response(bus, addr); 524 return bus->rirb_error ? -EIO : 0; 525 } 526 527 static const struct hdac_bus_ops bus_ops = { 528 .command = _hda_bus_command, 529 .get_response = _hda_bus_get_response, 530 }; 531 532 /** 533 * snd_hda_bus_new - create a HDA bus 534 * @card: the card entry 535 * @busp: the pointer to store the created bus instance 536 * 537 * Returns 0 if successful, or a negative error code. 538 */ 539 int snd_hda_bus_new(struct snd_card *card, 540 struct hda_bus **busp) 541 { 542 struct hda_bus *bus; 543 int err; 544 static struct snd_device_ops dev_ops = { 545 .dev_disconnect = snd_hda_bus_dev_disconnect, 546 .dev_free = snd_hda_bus_dev_free, 547 }; 548 549 if (busp) 550 *busp = NULL; 551 552 bus = kzalloc(sizeof(*bus), GFP_KERNEL); 553 if (!bus) 554 return -ENOMEM; 555 556 err = snd_hdac_bus_init(&bus->core, card->dev, &bus_ops); 557 if (err < 0) { 558 kfree(bus); 559 return err; 560 } 561 562 bus->card = card; 563 mutex_init(&bus->prepare_mutex); 564 565 err = snd_device_new(card, SNDRV_DEV_BUS, bus, &dev_ops); 566 if (err < 0) { 567 snd_hda_bus_free(bus); 568 return err; 569 } 570 if (busp) 571 *busp = bus; 572 return 0; 573 } 574 EXPORT_SYMBOL_GPL(snd_hda_bus_new); 575 576 /* 577 * read widget caps for each widget and store in cache 578 */ 579 static int read_widget_caps(struct hda_codec *codec, hda_nid_t fg_node) 580 { 581 int i; 582 hda_nid_t nid; 583 584 codec->wcaps = kmalloc(codec->core.num_nodes * 4, GFP_KERNEL); 585 if (!codec->wcaps) 586 return -ENOMEM; 587 nid = codec->core.start_nid; 588 for (i = 0; i < codec->core.num_nodes; i++, nid++) 589 codec->wcaps[i] = snd_hdac_read_parm_uncached(&codec->core, 590 nid, AC_PAR_AUDIO_WIDGET_CAP); 591 return 0; 592 } 593 594 /* read all pin default configurations and save codec->init_pins */ 595 static int read_pin_defaults(struct hda_codec *codec) 596 { 597 hda_nid_t nid; 598 599 for_each_hda_codec_node(nid, codec) { 600 struct hda_pincfg *pin; 601 unsigned int wcaps = get_wcaps(codec, nid); 602 unsigned int wid_type = get_wcaps_type(wcaps); 603 if (wid_type != AC_WID_PIN) 604 continue; 605 pin = snd_array_new(&codec->init_pins); 606 if (!pin) 607 return -ENOMEM; 608 pin->nid = nid; 609 pin->cfg = snd_hda_codec_read(codec, nid, 0, 610 AC_VERB_GET_CONFIG_DEFAULT, 0); 611 pin->ctrl = snd_hda_codec_read(codec, nid, 0, 612 AC_VERB_GET_PIN_WIDGET_CONTROL, 613 0); 614 } 615 return 0; 616 } 617 618 /* look up the given pin config list and return the item matching with NID */ 619 static struct hda_pincfg *look_up_pincfg(struct hda_codec *codec, 620 struct snd_array *array, 621 hda_nid_t nid) 622 { 623 int i; 624 for (i = 0; i < array->used; i++) { 625 struct hda_pincfg *pin = snd_array_elem(array, i); 626 if (pin->nid == nid) 627 return pin; 628 } 629 return NULL; 630 } 631 632 /* set the current pin config value for the given NID. 633 * the value is cached, and read via snd_hda_codec_get_pincfg() 634 */ 635 int snd_hda_add_pincfg(struct hda_codec *codec, struct snd_array *list, 636 hda_nid_t nid, unsigned int cfg) 637 { 638 struct hda_pincfg *pin; 639 640 /* the check below may be invalid when pins are added by a fixup 641 * dynamically (e.g. via snd_hda_codec_update_widgets()), so disabled 642 * for now 643 */ 644 /* 645 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN) 646 return -EINVAL; 647 */ 648 649 pin = look_up_pincfg(codec, list, nid); 650 if (!pin) { 651 pin = snd_array_new(list); 652 if (!pin) 653 return -ENOMEM; 654 pin->nid = nid; 655 } 656 pin->cfg = cfg; 657 return 0; 658 } 659 660 /** 661 * snd_hda_codec_set_pincfg - Override a pin default configuration 662 * @codec: the HDA codec 663 * @nid: NID to set the pin config 664 * @cfg: the pin default config value 665 * 666 * Override a pin default configuration value in the cache. 667 * This value can be read by snd_hda_codec_get_pincfg() in a higher 668 * priority than the real hardware value. 669 */ 670 int snd_hda_codec_set_pincfg(struct hda_codec *codec, 671 hda_nid_t nid, unsigned int cfg) 672 { 673 return snd_hda_add_pincfg(codec, &codec->driver_pins, nid, cfg); 674 } 675 EXPORT_SYMBOL_GPL(snd_hda_codec_set_pincfg); 676 677 /** 678 * snd_hda_codec_get_pincfg - Obtain a pin-default configuration 679 * @codec: the HDA codec 680 * @nid: NID to get the pin config 681 * 682 * Get the current pin config value of the given pin NID. 683 * If the pincfg value is cached or overridden via sysfs or driver, 684 * returns the cached value. 685 */ 686 unsigned int snd_hda_codec_get_pincfg(struct hda_codec *codec, hda_nid_t nid) 687 { 688 struct hda_pincfg *pin; 689 690 #ifdef CONFIG_SND_HDA_RECONFIG 691 { 692 unsigned int cfg = 0; 693 mutex_lock(&codec->user_mutex); 694 pin = look_up_pincfg(codec, &codec->user_pins, nid); 695 if (pin) 696 cfg = pin->cfg; 697 mutex_unlock(&codec->user_mutex); 698 if (cfg) 699 return cfg; 700 } 701 #endif 702 pin = look_up_pincfg(codec, &codec->driver_pins, nid); 703 if (pin) 704 return pin->cfg; 705 pin = look_up_pincfg(codec, &codec->init_pins, nid); 706 if (pin) 707 return pin->cfg; 708 return 0; 709 } 710 EXPORT_SYMBOL_GPL(snd_hda_codec_get_pincfg); 711 712 /** 713 * snd_hda_codec_set_pin_target - remember the current pinctl target value 714 * @codec: the HDA codec 715 * @nid: pin NID 716 * @val: assigned pinctl value 717 * 718 * This function stores the given value to a pinctl target value in the 719 * pincfg table. This isn't always as same as the actually written value 720 * but can be referred at any time via snd_hda_codec_get_pin_target(). 721 */ 722 int snd_hda_codec_set_pin_target(struct hda_codec *codec, hda_nid_t nid, 723 unsigned int val) 724 { 725 struct hda_pincfg *pin; 726 727 pin = look_up_pincfg(codec, &codec->init_pins, nid); 728 if (!pin) 729 return -EINVAL; 730 pin->target = val; 731 return 0; 732 } 733 EXPORT_SYMBOL_GPL(snd_hda_codec_set_pin_target); 734 735 /** 736 * snd_hda_codec_get_pin_target - return the current pinctl target value 737 * @codec: the HDA codec 738 * @nid: pin NID 739 */ 740 int snd_hda_codec_get_pin_target(struct hda_codec *codec, hda_nid_t nid) 741 { 742 struct hda_pincfg *pin; 743 744 pin = look_up_pincfg(codec, &codec->init_pins, nid); 745 if (!pin) 746 return 0; 747 return pin->target; 748 } 749 EXPORT_SYMBOL_GPL(snd_hda_codec_get_pin_target); 750 751 /** 752 * snd_hda_shutup_pins - Shut up all pins 753 * @codec: the HDA codec 754 * 755 * Clear all pin controls to shup up before suspend for avoiding click noise. 756 * The controls aren't cached so that they can be resumed properly. 757 */ 758 void snd_hda_shutup_pins(struct hda_codec *codec) 759 { 760 int i; 761 /* don't shut up pins when unloading the driver; otherwise it breaks 762 * the default pin setup at the next load of the driver 763 */ 764 if (codec->bus->shutdown) 765 return; 766 for (i = 0; i < codec->init_pins.used; i++) { 767 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i); 768 /* use read here for syncing after issuing each verb */ 769 snd_hda_codec_read(codec, pin->nid, 0, 770 AC_VERB_SET_PIN_WIDGET_CONTROL, 0); 771 } 772 codec->pins_shutup = 1; 773 } 774 EXPORT_SYMBOL_GPL(snd_hda_shutup_pins); 775 776 #ifdef CONFIG_PM 777 /* Restore the pin controls cleared previously via snd_hda_shutup_pins() */ 778 static void restore_shutup_pins(struct hda_codec *codec) 779 { 780 int i; 781 if (!codec->pins_shutup) 782 return; 783 if (codec->bus->shutdown) 784 return; 785 for (i = 0; i < codec->init_pins.used; i++) { 786 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i); 787 snd_hda_codec_write(codec, pin->nid, 0, 788 AC_VERB_SET_PIN_WIDGET_CONTROL, 789 pin->ctrl); 790 } 791 codec->pins_shutup = 0; 792 } 793 #endif 794 795 static void hda_jackpoll_work(struct work_struct *work) 796 { 797 struct hda_codec *codec = 798 container_of(work, struct hda_codec, jackpoll_work.work); 799 800 snd_hda_jack_set_dirty_all(codec); 801 snd_hda_jack_poll_all(codec); 802 803 if (!codec->jackpoll_interval) 804 return; 805 806 schedule_delayed_work(&codec->jackpoll_work, 807 codec->jackpoll_interval); 808 } 809 810 /* release all pincfg lists */ 811 static void free_init_pincfgs(struct hda_codec *codec) 812 { 813 snd_array_free(&codec->driver_pins); 814 #ifdef CONFIG_SND_HDA_RECONFIG 815 snd_array_free(&codec->user_pins); 816 #endif 817 snd_array_free(&codec->init_pins); 818 } 819 820 /* 821 * audio-converter setup caches 822 */ 823 struct hda_cvt_setup { 824 hda_nid_t nid; 825 u8 stream_tag; 826 u8 channel_id; 827 u16 format_id; 828 unsigned char active; /* cvt is currently used */ 829 unsigned char dirty; /* setups should be cleared */ 830 }; 831 832 /* get or create a cache entry for the given audio converter NID */ 833 static struct hda_cvt_setup * 834 get_hda_cvt_setup(struct hda_codec *codec, hda_nid_t nid) 835 { 836 struct hda_cvt_setup *p; 837 int i; 838 839 for (i = 0; i < codec->cvt_setups.used; i++) { 840 p = snd_array_elem(&codec->cvt_setups, i); 841 if (p->nid == nid) 842 return p; 843 } 844 p = snd_array_new(&codec->cvt_setups); 845 if (p) 846 p->nid = nid; 847 return p; 848 } 849 850 /* 851 * PCM device 852 */ 853 static void release_pcm(struct kref *kref) 854 { 855 struct hda_pcm *pcm = container_of(kref, struct hda_pcm, kref); 856 857 if (pcm->pcm) 858 snd_device_free(pcm->codec->card, pcm->pcm); 859 clear_bit(pcm->device, pcm->codec->bus->pcm_dev_bits); 860 kfree(pcm->name); 861 kfree(pcm); 862 } 863 864 void snd_hda_codec_pcm_put(struct hda_pcm *pcm) 865 { 866 kref_put(&pcm->kref, release_pcm); 867 } 868 EXPORT_SYMBOL_GPL(snd_hda_codec_pcm_put); 869 870 struct hda_pcm *snd_hda_codec_pcm_new(struct hda_codec *codec, 871 const char *fmt, ...) 872 { 873 struct hda_pcm *pcm; 874 va_list args; 875 876 pcm = kzalloc(sizeof(*pcm), GFP_KERNEL); 877 if (!pcm) 878 return NULL; 879 880 pcm->codec = codec; 881 kref_init(&pcm->kref); 882 va_start(args, fmt); 883 pcm->name = kvasprintf(GFP_KERNEL, fmt, args); 884 va_end(args); 885 if (!pcm->name) { 886 kfree(pcm); 887 return NULL; 888 } 889 890 list_add_tail(&pcm->list, &codec->pcm_list_head); 891 return pcm; 892 } 893 EXPORT_SYMBOL_GPL(snd_hda_codec_pcm_new); 894 895 /* 896 * codec destructor 897 */ 898 static void codec_release_pcms(struct hda_codec *codec) 899 { 900 struct hda_pcm *pcm, *n; 901 902 list_for_each_entry_safe(pcm, n, &codec->pcm_list_head, list) { 903 list_del_init(&pcm->list); 904 if (pcm->pcm) 905 snd_device_disconnect(codec->card, pcm->pcm); 906 snd_hda_codec_pcm_put(pcm); 907 } 908 } 909 910 void snd_hda_codec_cleanup_for_unbind(struct hda_codec *codec) 911 { 912 if (codec->registered) { 913 /* pm_runtime_put() is called in snd_hdac_device_exit() */ 914 pm_runtime_get_noresume(hda_codec_dev(codec)); 915 pm_runtime_disable(hda_codec_dev(codec)); 916 codec->registered = 0; 917 } 918 919 cancel_delayed_work_sync(&codec->jackpoll_work); 920 if (!codec->in_freeing) 921 snd_hda_ctls_clear(codec); 922 codec_release_pcms(codec); 923 snd_hda_detach_beep_device(codec); 924 memset(&codec->patch_ops, 0, sizeof(codec->patch_ops)); 925 snd_hda_jack_tbl_clear(codec); 926 codec->proc_widget_hook = NULL; 927 codec->spec = NULL; 928 929 /* free only driver_pins so that init_pins + user_pins are restored */ 930 snd_array_free(&codec->driver_pins); 931 snd_array_free(&codec->cvt_setups); 932 snd_array_free(&codec->spdif_out); 933 snd_array_free(&codec->verbs); 934 codec->preset = NULL; 935 codec->slave_dig_outs = NULL; 936 codec->spdif_status_reset = 0; 937 snd_array_free(&codec->mixers); 938 snd_array_free(&codec->nids); 939 remove_conn_list(codec); 940 snd_hdac_regmap_exit(&codec->core); 941 } 942 943 static unsigned int hda_set_power_state(struct hda_codec *codec, 944 unsigned int power_state); 945 946 /* also called from hda_bind.c */ 947 void snd_hda_codec_register(struct hda_codec *codec) 948 { 949 if (codec->registered) 950 return; 951 if (device_is_registered(hda_codec_dev(codec))) { 952 snd_hda_register_beep_device(codec); 953 pm_runtime_enable(hda_codec_dev(codec)); 954 /* it was powered up in snd_hda_codec_new(), now all done */ 955 snd_hda_power_down(codec); 956 codec->registered = 1; 957 } 958 } 959 960 static int snd_hda_codec_dev_register(struct snd_device *device) 961 { 962 snd_hda_codec_register(device->device_data); 963 return 0; 964 } 965 966 static int snd_hda_codec_dev_disconnect(struct snd_device *device) 967 { 968 struct hda_codec *codec = device->device_data; 969 970 snd_hda_detach_beep_device(codec); 971 return 0; 972 } 973 974 static int snd_hda_codec_dev_free(struct snd_device *device) 975 { 976 struct hda_codec *codec = device->device_data; 977 978 codec->in_freeing = 1; 979 snd_hdac_device_unregister(&codec->core); 980 put_device(hda_codec_dev(codec)); 981 return 0; 982 } 983 984 static void snd_hda_codec_dev_release(struct device *dev) 985 { 986 struct hda_codec *codec = dev_to_hda_codec(dev); 987 988 free_init_pincfgs(codec); 989 snd_hdac_device_exit(&codec->core); 990 snd_hda_sysfs_clear(codec); 991 kfree(codec->modelname); 992 kfree(codec->wcaps); 993 kfree(codec); 994 } 995 996 /** 997 * snd_hda_codec_new - create a HDA codec 998 * @bus: the bus to assign 999 * @codec_addr: the codec address 1000 * @codecp: the pointer to store the generated codec 1001 * 1002 * Returns 0 if successful, or a negative error code. 1003 */ 1004 int snd_hda_codec_new(struct hda_bus *bus, struct snd_card *card, 1005 unsigned int codec_addr, struct hda_codec **codecp) 1006 { 1007 struct hda_codec *codec; 1008 char component[31]; 1009 hda_nid_t fg; 1010 int err; 1011 static struct snd_device_ops dev_ops = { 1012 .dev_register = snd_hda_codec_dev_register, 1013 .dev_disconnect = snd_hda_codec_dev_disconnect, 1014 .dev_free = snd_hda_codec_dev_free, 1015 }; 1016 1017 if (snd_BUG_ON(!bus)) 1018 return -EINVAL; 1019 if (snd_BUG_ON(codec_addr > HDA_MAX_CODEC_ADDRESS)) 1020 return -EINVAL; 1021 1022 codec = kzalloc(sizeof(*codec), GFP_KERNEL); 1023 if (!codec) 1024 return -ENOMEM; 1025 1026 sprintf(component, "hdaudioC%dD%d", card->number, codec_addr); 1027 err = snd_hdac_device_init(&codec->core, &bus->core, component, 1028 codec_addr); 1029 if (err < 0) { 1030 kfree(codec); 1031 return err; 1032 } 1033 1034 codec->core.dev.release = snd_hda_codec_dev_release; 1035 codec->core.type = HDA_DEV_LEGACY; 1036 codec->core.exec_verb = codec_exec_verb; 1037 1038 codec->bus = bus; 1039 codec->card = card; 1040 codec->addr = codec_addr; 1041 mutex_init(&codec->spdif_mutex); 1042 mutex_init(&codec->control_mutex); 1043 snd_array_init(&codec->mixers, sizeof(struct hda_nid_item), 32); 1044 snd_array_init(&codec->nids, sizeof(struct hda_nid_item), 32); 1045 snd_array_init(&codec->init_pins, sizeof(struct hda_pincfg), 16); 1046 snd_array_init(&codec->driver_pins, sizeof(struct hda_pincfg), 16); 1047 snd_array_init(&codec->cvt_setups, sizeof(struct hda_cvt_setup), 8); 1048 snd_array_init(&codec->spdif_out, sizeof(struct hda_spdif_out), 16); 1049 snd_array_init(&codec->jacktbl, sizeof(struct hda_jack_tbl), 16); 1050 snd_array_init(&codec->verbs, sizeof(struct hda_verb *), 8); 1051 INIT_LIST_HEAD(&codec->conn_list); 1052 INIT_LIST_HEAD(&codec->pcm_list_head); 1053 1054 INIT_DELAYED_WORK(&codec->jackpoll_work, hda_jackpoll_work); 1055 codec->depop_delay = -1; 1056 codec->fixup_id = HDA_FIXUP_ID_NOT_SET; 1057 1058 #ifdef CONFIG_PM 1059 codec->power_jiffies = jiffies; 1060 #endif 1061 1062 snd_hda_sysfs_init(codec); 1063 1064 if (codec->bus->modelname) { 1065 codec->modelname = kstrdup(codec->bus->modelname, GFP_KERNEL); 1066 if (!codec->modelname) { 1067 err = -ENODEV; 1068 goto error; 1069 } 1070 } 1071 1072 fg = codec->core.afg ? codec->core.afg : codec->core.mfg; 1073 err = read_widget_caps(codec, fg); 1074 if (err < 0) 1075 goto error; 1076 err = read_pin_defaults(codec); 1077 if (err < 0) 1078 goto error; 1079 1080 /* power-up all before initialization */ 1081 hda_set_power_state(codec, AC_PWRST_D0); 1082 1083 snd_hda_codec_proc_new(codec); 1084 1085 snd_hda_create_hwdep(codec); 1086 1087 sprintf(component, "HDA:%08x,%08x,%08x", codec->core.vendor_id, 1088 codec->core.subsystem_id, codec->core.revision_id); 1089 snd_component_add(card, component); 1090 1091 err = snd_device_new(card, SNDRV_DEV_CODEC, codec, &dev_ops); 1092 if (err < 0) 1093 goto error; 1094 1095 if (codecp) 1096 *codecp = codec; 1097 return 0; 1098 1099 error: 1100 put_device(hda_codec_dev(codec)); 1101 return err; 1102 } 1103 EXPORT_SYMBOL_GPL(snd_hda_codec_new); 1104 1105 /** 1106 * snd_hda_codec_update_widgets - Refresh widget caps and pin defaults 1107 * @codec: the HDA codec 1108 * 1109 * Forcibly refresh the all widget caps and the init pin configurations of 1110 * the given codec. 1111 */ 1112 int snd_hda_codec_update_widgets(struct hda_codec *codec) 1113 { 1114 hda_nid_t fg; 1115 int err; 1116 1117 err = snd_hdac_refresh_widgets(&codec->core); 1118 if (err < 0) 1119 return err; 1120 1121 /* Assume the function group node does not change, 1122 * only the widget nodes may change. 1123 */ 1124 kfree(codec->wcaps); 1125 fg = codec->core.afg ? codec->core.afg : codec->core.mfg; 1126 err = read_widget_caps(codec, fg); 1127 if (err < 0) 1128 return err; 1129 1130 snd_array_free(&codec->init_pins); 1131 err = read_pin_defaults(codec); 1132 1133 return err; 1134 } 1135 EXPORT_SYMBOL_GPL(snd_hda_codec_update_widgets); 1136 1137 /* update the stream-id if changed */ 1138 static void update_pcm_stream_id(struct hda_codec *codec, 1139 struct hda_cvt_setup *p, hda_nid_t nid, 1140 u32 stream_tag, int channel_id) 1141 { 1142 unsigned int oldval, newval; 1143 1144 if (p->stream_tag != stream_tag || p->channel_id != channel_id) { 1145 oldval = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONV, 0); 1146 newval = (stream_tag << 4) | channel_id; 1147 if (oldval != newval) 1148 snd_hda_codec_write(codec, nid, 0, 1149 AC_VERB_SET_CHANNEL_STREAMID, 1150 newval); 1151 p->stream_tag = stream_tag; 1152 p->channel_id = channel_id; 1153 } 1154 } 1155 1156 /* update the format-id if changed */ 1157 static void update_pcm_format(struct hda_codec *codec, struct hda_cvt_setup *p, 1158 hda_nid_t nid, int format) 1159 { 1160 unsigned int oldval; 1161 1162 if (p->format_id != format) { 1163 oldval = snd_hda_codec_read(codec, nid, 0, 1164 AC_VERB_GET_STREAM_FORMAT, 0); 1165 if (oldval != format) { 1166 msleep(1); 1167 snd_hda_codec_write(codec, nid, 0, 1168 AC_VERB_SET_STREAM_FORMAT, 1169 format); 1170 } 1171 p->format_id = format; 1172 } 1173 } 1174 1175 /** 1176 * snd_hda_codec_setup_stream - set up the codec for streaming 1177 * @codec: the CODEC to set up 1178 * @nid: the NID to set up 1179 * @stream_tag: stream tag to pass, it's between 0x1 and 0xf. 1180 * @channel_id: channel id to pass, zero based. 1181 * @format: stream format. 1182 */ 1183 void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid, 1184 u32 stream_tag, 1185 int channel_id, int format) 1186 { 1187 struct hda_codec *c; 1188 struct hda_cvt_setup *p; 1189 int type; 1190 int i; 1191 1192 if (!nid) 1193 return; 1194 1195 codec_dbg(codec, 1196 "hda_codec_setup_stream: NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n", 1197 nid, stream_tag, channel_id, format); 1198 p = get_hda_cvt_setup(codec, nid); 1199 if (!p) 1200 return; 1201 1202 if (codec->patch_ops.stream_pm) 1203 codec->patch_ops.stream_pm(codec, nid, true); 1204 if (codec->pcm_format_first) 1205 update_pcm_format(codec, p, nid, format); 1206 update_pcm_stream_id(codec, p, nid, stream_tag, channel_id); 1207 if (!codec->pcm_format_first) 1208 update_pcm_format(codec, p, nid, format); 1209 1210 p->active = 1; 1211 p->dirty = 0; 1212 1213 /* make other inactive cvts with the same stream-tag dirty */ 1214 type = get_wcaps_type(get_wcaps(codec, nid)); 1215 list_for_each_codec(c, codec->bus) { 1216 for (i = 0; i < c->cvt_setups.used; i++) { 1217 p = snd_array_elem(&c->cvt_setups, i); 1218 if (!p->active && p->stream_tag == stream_tag && 1219 get_wcaps_type(get_wcaps(c, p->nid)) == type) 1220 p->dirty = 1; 1221 } 1222 } 1223 } 1224 EXPORT_SYMBOL_GPL(snd_hda_codec_setup_stream); 1225 1226 static void really_cleanup_stream(struct hda_codec *codec, 1227 struct hda_cvt_setup *q); 1228 1229 /** 1230 * __snd_hda_codec_cleanup_stream - clean up the codec for closing 1231 * @codec: the CODEC to clean up 1232 * @nid: the NID to clean up 1233 * @do_now: really clean up the stream instead of clearing the active flag 1234 */ 1235 void __snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid, 1236 int do_now) 1237 { 1238 struct hda_cvt_setup *p; 1239 1240 if (!nid) 1241 return; 1242 1243 if (codec->no_sticky_stream) 1244 do_now = 1; 1245 1246 codec_dbg(codec, "hda_codec_cleanup_stream: NID=0x%x\n", nid); 1247 p = get_hda_cvt_setup(codec, nid); 1248 if (p) { 1249 /* here we just clear the active flag when do_now isn't set; 1250 * actual clean-ups will be done later in 1251 * purify_inactive_streams() called from snd_hda_codec_prpapre() 1252 */ 1253 if (do_now) 1254 really_cleanup_stream(codec, p); 1255 else 1256 p->active = 0; 1257 } 1258 } 1259 EXPORT_SYMBOL_GPL(__snd_hda_codec_cleanup_stream); 1260 1261 static void really_cleanup_stream(struct hda_codec *codec, 1262 struct hda_cvt_setup *q) 1263 { 1264 hda_nid_t nid = q->nid; 1265 if (q->stream_tag || q->channel_id) 1266 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 0); 1267 if (q->format_id) 1268 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, 0 1269 ); 1270 memset(q, 0, sizeof(*q)); 1271 q->nid = nid; 1272 if (codec->patch_ops.stream_pm) 1273 codec->patch_ops.stream_pm(codec, nid, false); 1274 } 1275 1276 /* clean up the all conflicting obsolete streams */ 1277 static void purify_inactive_streams(struct hda_codec *codec) 1278 { 1279 struct hda_codec *c; 1280 int i; 1281 1282 list_for_each_codec(c, codec->bus) { 1283 for (i = 0; i < c->cvt_setups.used; i++) { 1284 struct hda_cvt_setup *p; 1285 p = snd_array_elem(&c->cvt_setups, i); 1286 if (p->dirty) 1287 really_cleanup_stream(c, p); 1288 } 1289 } 1290 } 1291 1292 #ifdef CONFIG_PM 1293 /* clean up all streams; called from suspend */ 1294 static void hda_cleanup_all_streams(struct hda_codec *codec) 1295 { 1296 int i; 1297 1298 for (i = 0; i < codec->cvt_setups.used; i++) { 1299 struct hda_cvt_setup *p = snd_array_elem(&codec->cvt_setups, i); 1300 if (p->stream_tag) 1301 really_cleanup_stream(codec, p); 1302 } 1303 } 1304 #endif 1305 1306 /* 1307 * amp access functions 1308 */ 1309 1310 /** 1311 * query_amp_caps - query AMP capabilities 1312 * @codec: the HD-auio codec 1313 * @nid: the NID to query 1314 * @direction: either #HDA_INPUT or #HDA_OUTPUT 1315 * 1316 * Query AMP capabilities for the given widget and direction. 1317 * Returns the obtained capability bits. 1318 * 1319 * When cap bits have been already read, this doesn't read again but 1320 * returns the cached value. 1321 */ 1322 u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction) 1323 { 1324 if (!(get_wcaps(codec, nid) & AC_WCAP_AMP_OVRD)) 1325 nid = codec->core.afg; 1326 return snd_hda_param_read(codec, nid, 1327 direction == HDA_OUTPUT ? 1328 AC_PAR_AMP_OUT_CAP : AC_PAR_AMP_IN_CAP); 1329 } 1330 EXPORT_SYMBOL_GPL(query_amp_caps); 1331 1332 /** 1333 * snd_hda_check_amp_caps - query AMP capabilities 1334 * @codec: the HD-audio codec 1335 * @nid: the NID to query 1336 * @dir: either #HDA_INPUT or #HDA_OUTPUT 1337 * @bits: bit mask to check the result 1338 * 1339 * Check whether the widget has the given amp capability for the direction. 1340 */ 1341 bool snd_hda_check_amp_caps(struct hda_codec *codec, hda_nid_t nid, 1342 int dir, unsigned int bits) 1343 { 1344 if (!nid) 1345 return false; 1346 if (get_wcaps(codec, nid) & (1 << (dir + 1))) 1347 if (query_amp_caps(codec, nid, dir) & bits) 1348 return true; 1349 return false; 1350 } 1351 EXPORT_SYMBOL_GPL(snd_hda_check_amp_caps); 1352 1353 /** 1354 * snd_hda_override_amp_caps - Override the AMP capabilities 1355 * @codec: the CODEC to clean up 1356 * @nid: the NID to clean up 1357 * @dir: either #HDA_INPUT or #HDA_OUTPUT 1358 * @caps: the capability bits to set 1359 * 1360 * Override the cached AMP caps bits value by the given one. 1361 * This function is useful if the driver needs to adjust the AMP ranges, 1362 * e.g. limit to 0dB, etc. 1363 * 1364 * Returns zero if successful or a negative error code. 1365 */ 1366 int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir, 1367 unsigned int caps) 1368 { 1369 unsigned int parm; 1370 1371 snd_hda_override_wcaps(codec, nid, 1372 get_wcaps(codec, nid) | AC_WCAP_AMP_OVRD); 1373 parm = dir == HDA_OUTPUT ? AC_PAR_AMP_OUT_CAP : AC_PAR_AMP_IN_CAP; 1374 return snd_hdac_override_parm(&codec->core, nid, parm, caps); 1375 } 1376 EXPORT_SYMBOL_GPL(snd_hda_override_amp_caps); 1377 1378 /** 1379 * snd_hda_codec_amp_stereo - update the AMP stereo values 1380 * @codec: HD-audio codec 1381 * @nid: NID to read the AMP value 1382 * @direction: #HDA_INPUT or #HDA_OUTPUT 1383 * @idx: the index value (only for input direction) 1384 * @mask: bit mask to set 1385 * @val: the bits value to set 1386 * 1387 * Update the AMP values like snd_hda_codec_amp_update(), but for a 1388 * stereo widget with the same mask and value. 1389 */ 1390 int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid, 1391 int direction, int idx, int mask, int val) 1392 { 1393 int ch, ret = 0; 1394 1395 if (snd_BUG_ON(mask & ~0xff)) 1396 mask &= 0xff; 1397 for (ch = 0; ch < 2; ch++) 1398 ret |= snd_hda_codec_amp_update(codec, nid, ch, direction, 1399 idx, mask, val); 1400 return ret; 1401 } 1402 EXPORT_SYMBOL_GPL(snd_hda_codec_amp_stereo); 1403 1404 /** 1405 * snd_hda_codec_amp_init - initialize the AMP value 1406 * @codec: the HDA codec 1407 * @nid: NID to read the AMP value 1408 * @ch: channel (left=0 or right=1) 1409 * @dir: #HDA_INPUT or #HDA_OUTPUT 1410 * @idx: the index value (only for input direction) 1411 * @mask: bit mask to set 1412 * @val: the bits value to set 1413 * 1414 * Works like snd_hda_codec_amp_update() but it writes the value only at 1415 * the first access. If the amp was already initialized / updated beforehand, 1416 * this does nothing. 1417 */ 1418 int snd_hda_codec_amp_init(struct hda_codec *codec, hda_nid_t nid, int ch, 1419 int dir, int idx, int mask, int val) 1420 { 1421 int orig; 1422 1423 if (!codec->core.regmap) 1424 return -EINVAL; 1425 regcache_cache_only(codec->core.regmap, true); 1426 orig = snd_hda_codec_amp_read(codec, nid, ch, dir, idx); 1427 regcache_cache_only(codec->core.regmap, false); 1428 if (orig >= 0) 1429 return 0; 1430 return snd_hda_codec_amp_update(codec, nid, ch, dir, idx, mask, val); 1431 } 1432 EXPORT_SYMBOL_GPL(snd_hda_codec_amp_init); 1433 1434 /** 1435 * snd_hda_codec_amp_init_stereo - initialize the stereo AMP value 1436 * @codec: the HDA codec 1437 * @nid: NID to read the AMP value 1438 * @dir: #HDA_INPUT or #HDA_OUTPUT 1439 * @idx: the index value (only for input direction) 1440 * @mask: bit mask to set 1441 * @val: the bits value to set 1442 * 1443 * Call snd_hda_codec_amp_init() for both stereo channels. 1444 */ 1445 int snd_hda_codec_amp_init_stereo(struct hda_codec *codec, hda_nid_t nid, 1446 int dir, int idx, int mask, int val) 1447 { 1448 int ch, ret = 0; 1449 1450 if (snd_BUG_ON(mask & ~0xff)) 1451 mask &= 0xff; 1452 for (ch = 0; ch < 2; ch++) 1453 ret |= snd_hda_codec_amp_init(codec, nid, ch, dir, 1454 idx, mask, val); 1455 return ret; 1456 } 1457 EXPORT_SYMBOL_GPL(snd_hda_codec_amp_init_stereo); 1458 1459 static u32 get_amp_max_value(struct hda_codec *codec, hda_nid_t nid, int dir, 1460 unsigned int ofs) 1461 { 1462 u32 caps = query_amp_caps(codec, nid, dir); 1463 /* get num steps */ 1464 caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT; 1465 if (ofs < caps) 1466 caps -= ofs; 1467 return caps; 1468 } 1469 1470 /** 1471 * snd_hda_mixer_amp_volume_info - Info callback for a standard AMP mixer 1472 * @kcontrol: referred ctl element 1473 * @uinfo: pointer to get/store the data 1474 * 1475 * The control element is supposed to have the private_value field 1476 * set up via HDA_COMPOSE_AMP_VAL*() or related macros. 1477 */ 1478 int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol, 1479 struct snd_ctl_elem_info *uinfo) 1480 { 1481 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1482 u16 nid = get_amp_nid(kcontrol); 1483 u8 chs = get_amp_channels(kcontrol); 1484 int dir = get_amp_direction(kcontrol); 1485 unsigned int ofs = get_amp_offset(kcontrol); 1486 1487 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 1488 uinfo->count = chs == 3 ? 2 : 1; 1489 uinfo->value.integer.min = 0; 1490 uinfo->value.integer.max = get_amp_max_value(codec, nid, dir, ofs); 1491 if (!uinfo->value.integer.max) { 1492 codec_warn(codec, 1493 "num_steps = 0 for NID=0x%x (ctl = %s)\n", 1494 nid, kcontrol->id.name); 1495 return -EINVAL; 1496 } 1497 return 0; 1498 } 1499 EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_volume_info); 1500 1501 1502 static inline unsigned int 1503 read_amp_value(struct hda_codec *codec, hda_nid_t nid, 1504 int ch, int dir, int idx, unsigned int ofs) 1505 { 1506 unsigned int val; 1507 val = snd_hda_codec_amp_read(codec, nid, ch, dir, idx); 1508 val &= HDA_AMP_VOLMASK; 1509 if (val >= ofs) 1510 val -= ofs; 1511 else 1512 val = 0; 1513 return val; 1514 } 1515 1516 static inline int 1517 update_amp_value(struct hda_codec *codec, hda_nid_t nid, 1518 int ch, int dir, int idx, unsigned int ofs, 1519 unsigned int val) 1520 { 1521 unsigned int maxval; 1522 1523 if (val > 0) 1524 val += ofs; 1525 /* ofs = 0: raw max value */ 1526 maxval = get_amp_max_value(codec, nid, dir, 0); 1527 if (val > maxval) 1528 val = maxval; 1529 return snd_hda_codec_amp_update(codec, nid, ch, dir, idx, 1530 HDA_AMP_VOLMASK, val); 1531 } 1532 1533 /** 1534 * snd_hda_mixer_amp_volume_get - Get callback for a standard AMP mixer volume 1535 * @kcontrol: ctl element 1536 * @ucontrol: pointer to get/store the data 1537 * 1538 * The control element is supposed to have the private_value field 1539 * set up via HDA_COMPOSE_AMP_VAL*() or related macros. 1540 */ 1541 int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol, 1542 struct snd_ctl_elem_value *ucontrol) 1543 { 1544 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1545 hda_nid_t nid = get_amp_nid(kcontrol); 1546 int chs = get_amp_channels(kcontrol); 1547 int dir = get_amp_direction(kcontrol); 1548 int idx = get_amp_index(kcontrol); 1549 unsigned int ofs = get_amp_offset(kcontrol); 1550 long *valp = ucontrol->value.integer.value; 1551 1552 if (chs & 1) 1553 *valp++ = read_amp_value(codec, nid, 0, dir, idx, ofs); 1554 if (chs & 2) 1555 *valp = read_amp_value(codec, nid, 1, dir, idx, ofs); 1556 return 0; 1557 } 1558 EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_volume_get); 1559 1560 /** 1561 * snd_hda_mixer_amp_volume_put - Put callback for a standard AMP mixer volume 1562 * @kcontrol: ctl element 1563 * @ucontrol: pointer to get/store the data 1564 * 1565 * The control element is supposed to have the private_value field 1566 * set up via HDA_COMPOSE_AMP_VAL*() or related macros. 1567 */ 1568 int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol, 1569 struct snd_ctl_elem_value *ucontrol) 1570 { 1571 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1572 hda_nid_t nid = get_amp_nid(kcontrol); 1573 int chs = get_amp_channels(kcontrol); 1574 int dir = get_amp_direction(kcontrol); 1575 int idx = get_amp_index(kcontrol); 1576 unsigned int ofs = get_amp_offset(kcontrol); 1577 long *valp = ucontrol->value.integer.value; 1578 int change = 0; 1579 1580 if (chs & 1) { 1581 change = update_amp_value(codec, nid, 0, dir, idx, ofs, *valp); 1582 valp++; 1583 } 1584 if (chs & 2) 1585 change |= update_amp_value(codec, nid, 1, dir, idx, ofs, *valp); 1586 return change; 1587 } 1588 EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_volume_put); 1589 1590 /** 1591 * snd_hda_mixer_amp_volume_put - TLV callback for a standard AMP mixer volume 1592 * @kcontrol: ctl element 1593 * @op_flag: operation flag 1594 * @size: byte size of input TLV 1595 * @_tlv: TLV data 1596 * 1597 * The control element is supposed to have the private_value field 1598 * set up via HDA_COMPOSE_AMP_VAL*() or related macros. 1599 */ 1600 int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag, 1601 unsigned int size, unsigned int __user *_tlv) 1602 { 1603 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1604 hda_nid_t nid = get_amp_nid(kcontrol); 1605 int dir = get_amp_direction(kcontrol); 1606 unsigned int ofs = get_amp_offset(kcontrol); 1607 bool min_mute = get_amp_min_mute(kcontrol); 1608 u32 caps, val1, val2; 1609 1610 if (size < 4 * sizeof(unsigned int)) 1611 return -ENOMEM; 1612 caps = query_amp_caps(codec, nid, dir); 1613 val2 = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT; 1614 val2 = (val2 + 1) * 25; 1615 val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT); 1616 val1 += ofs; 1617 val1 = ((int)val1) * ((int)val2); 1618 if (min_mute || (caps & AC_AMPCAP_MIN_MUTE)) 1619 val2 |= TLV_DB_SCALE_MUTE; 1620 if (put_user(SNDRV_CTL_TLVT_DB_SCALE, _tlv)) 1621 return -EFAULT; 1622 if (put_user(2 * sizeof(unsigned int), _tlv + 1)) 1623 return -EFAULT; 1624 if (put_user(val1, _tlv + 2)) 1625 return -EFAULT; 1626 if (put_user(val2, _tlv + 3)) 1627 return -EFAULT; 1628 return 0; 1629 } 1630 EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_tlv); 1631 1632 /** 1633 * snd_hda_set_vmaster_tlv - Set TLV for a virtual master control 1634 * @codec: HD-audio codec 1635 * @nid: NID of a reference widget 1636 * @dir: #HDA_INPUT or #HDA_OUTPUT 1637 * @tlv: TLV data to be stored, at least 4 elements 1638 * 1639 * Set (static) TLV data for a virtual master volume using the AMP caps 1640 * obtained from the reference NID. 1641 * The volume range is recalculated as if the max volume is 0dB. 1642 */ 1643 void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir, 1644 unsigned int *tlv) 1645 { 1646 u32 caps; 1647 int nums, step; 1648 1649 caps = query_amp_caps(codec, nid, dir); 1650 nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT; 1651 step = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT; 1652 step = (step + 1) * 25; 1653 tlv[0] = SNDRV_CTL_TLVT_DB_SCALE; 1654 tlv[1] = 2 * sizeof(unsigned int); 1655 tlv[2] = -nums * step; 1656 tlv[3] = step; 1657 } 1658 EXPORT_SYMBOL_GPL(snd_hda_set_vmaster_tlv); 1659 1660 /* find a mixer control element with the given name */ 1661 static struct snd_kcontrol * 1662 find_mixer_ctl(struct hda_codec *codec, const char *name, int dev, int idx) 1663 { 1664 struct snd_ctl_elem_id id; 1665 memset(&id, 0, sizeof(id)); 1666 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER; 1667 id.device = dev; 1668 id.index = idx; 1669 if (snd_BUG_ON(strlen(name) >= sizeof(id.name))) 1670 return NULL; 1671 strcpy(id.name, name); 1672 return snd_ctl_find_id(codec->card, &id); 1673 } 1674 1675 /** 1676 * snd_hda_find_mixer_ctl - Find a mixer control element with the given name 1677 * @codec: HD-audio codec 1678 * @name: ctl id name string 1679 * 1680 * Get the control element with the given id string and IFACE_MIXER. 1681 */ 1682 struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec, 1683 const char *name) 1684 { 1685 return find_mixer_ctl(codec, name, 0, 0); 1686 } 1687 EXPORT_SYMBOL_GPL(snd_hda_find_mixer_ctl); 1688 1689 static int find_empty_mixer_ctl_idx(struct hda_codec *codec, const char *name, 1690 int start_idx) 1691 { 1692 int i, idx; 1693 /* 16 ctlrs should be large enough */ 1694 for (i = 0, idx = start_idx; i < 16; i++, idx++) { 1695 if (!find_mixer_ctl(codec, name, 0, idx)) 1696 return idx; 1697 } 1698 return -EBUSY; 1699 } 1700 1701 /** 1702 * snd_hda_ctl_add - Add a control element and assign to the codec 1703 * @codec: HD-audio codec 1704 * @nid: corresponding NID (optional) 1705 * @kctl: the control element to assign 1706 * 1707 * Add the given control element to an array inside the codec instance. 1708 * All control elements belonging to a codec are supposed to be added 1709 * by this function so that a proper clean-up works at the free or 1710 * reconfiguration time. 1711 * 1712 * If non-zero @nid is passed, the NID is assigned to the control element. 1713 * The assignment is shown in the codec proc file. 1714 * 1715 * snd_hda_ctl_add() checks the control subdev id field whether 1716 * #HDA_SUBDEV_NID_FLAG bit is set. If set (and @nid is zero), the lower 1717 * bits value is taken as the NID to assign. The #HDA_NID_ITEM_AMP bit 1718 * specifies if kctl->private_value is a HDA amplifier value. 1719 */ 1720 int snd_hda_ctl_add(struct hda_codec *codec, hda_nid_t nid, 1721 struct snd_kcontrol *kctl) 1722 { 1723 int err; 1724 unsigned short flags = 0; 1725 struct hda_nid_item *item; 1726 1727 if (kctl->id.subdevice & HDA_SUBDEV_AMP_FLAG) { 1728 flags |= HDA_NID_ITEM_AMP; 1729 if (nid == 0) 1730 nid = get_amp_nid_(kctl->private_value); 1731 } 1732 if ((kctl->id.subdevice & HDA_SUBDEV_NID_FLAG) != 0 && nid == 0) 1733 nid = kctl->id.subdevice & 0xffff; 1734 if (kctl->id.subdevice & (HDA_SUBDEV_NID_FLAG|HDA_SUBDEV_AMP_FLAG)) 1735 kctl->id.subdevice = 0; 1736 err = snd_ctl_add(codec->card, kctl); 1737 if (err < 0) 1738 return err; 1739 item = snd_array_new(&codec->mixers); 1740 if (!item) 1741 return -ENOMEM; 1742 item->kctl = kctl; 1743 item->nid = nid; 1744 item->flags = flags; 1745 return 0; 1746 } 1747 EXPORT_SYMBOL_GPL(snd_hda_ctl_add); 1748 1749 /** 1750 * snd_hda_add_nid - Assign a NID to a control element 1751 * @codec: HD-audio codec 1752 * @nid: corresponding NID (optional) 1753 * @kctl: the control element to assign 1754 * @index: index to kctl 1755 * 1756 * Add the given control element to an array inside the codec instance. 1757 * This function is used when #snd_hda_ctl_add cannot be used for 1:1 1758 * NID:KCTL mapping - for example "Capture Source" selector. 1759 */ 1760 int snd_hda_add_nid(struct hda_codec *codec, struct snd_kcontrol *kctl, 1761 unsigned int index, hda_nid_t nid) 1762 { 1763 struct hda_nid_item *item; 1764 1765 if (nid > 0) { 1766 item = snd_array_new(&codec->nids); 1767 if (!item) 1768 return -ENOMEM; 1769 item->kctl = kctl; 1770 item->index = index; 1771 item->nid = nid; 1772 return 0; 1773 } 1774 codec_err(codec, "no NID for mapping control %s:%d:%d\n", 1775 kctl->id.name, kctl->id.index, index); 1776 return -EINVAL; 1777 } 1778 EXPORT_SYMBOL_GPL(snd_hda_add_nid); 1779 1780 /** 1781 * snd_hda_ctls_clear - Clear all controls assigned to the given codec 1782 * @codec: HD-audio codec 1783 */ 1784 void snd_hda_ctls_clear(struct hda_codec *codec) 1785 { 1786 int i; 1787 struct hda_nid_item *items = codec->mixers.list; 1788 for (i = 0; i < codec->mixers.used; i++) 1789 snd_ctl_remove(codec->card, items[i].kctl); 1790 snd_array_free(&codec->mixers); 1791 snd_array_free(&codec->nids); 1792 } 1793 1794 /** 1795 * snd_hda_lock_devices - pseudo device locking 1796 * @bus: the BUS 1797 * 1798 * toggle card->shutdown to allow/disallow the device access (as a hack) 1799 */ 1800 int snd_hda_lock_devices(struct hda_bus *bus) 1801 { 1802 struct snd_card *card = bus->card; 1803 struct hda_codec *codec; 1804 1805 spin_lock(&card->files_lock); 1806 if (card->shutdown) 1807 goto err_unlock; 1808 card->shutdown = 1; 1809 if (!list_empty(&card->ctl_files)) 1810 goto err_clear; 1811 1812 list_for_each_codec(codec, bus) { 1813 struct hda_pcm *cpcm; 1814 list_for_each_entry(cpcm, &codec->pcm_list_head, list) { 1815 if (!cpcm->pcm) 1816 continue; 1817 if (cpcm->pcm->streams[0].substream_opened || 1818 cpcm->pcm->streams[1].substream_opened) 1819 goto err_clear; 1820 } 1821 } 1822 spin_unlock(&card->files_lock); 1823 return 0; 1824 1825 err_clear: 1826 card->shutdown = 0; 1827 err_unlock: 1828 spin_unlock(&card->files_lock); 1829 return -EINVAL; 1830 } 1831 EXPORT_SYMBOL_GPL(snd_hda_lock_devices); 1832 1833 /** 1834 * snd_hda_unlock_devices - pseudo device unlocking 1835 * @bus: the BUS 1836 */ 1837 void snd_hda_unlock_devices(struct hda_bus *bus) 1838 { 1839 struct snd_card *card = bus->card; 1840 1841 spin_lock(&card->files_lock); 1842 card->shutdown = 0; 1843 spin_unlock(&card->files_lock); 1844 } 1845 EXPORT_SYMBOL_GPL(snd_hda_unlock_devices); 1846 1847 /** 1848 * snd_hda_codec_reset - Clear all objects assigned to the codec 1849 * @codec: HD-audio codec 1850 * 1851 * This frees the all PCM and control elements assigned to the codec, and 1852 * clears the caches and restores the pin default configurations. 1853 * 1854 * When a device is being used, it returns -EBSY. If successfully freed, 1855 * returns zero. 1856 */ 1857 int snd_hda_codec_reset(struct hda_codec *codec) 1858 { 1859 struct hda_bus *bus = codec->bus; 1860 1861 if (snd_hda_lock_devices(bus) < 0) 1862 return -EBUSY; 1863 1864 /* OK, let it free */ 1865 snd_hdac_device_unregister(&codec->core); 1866 1867 /* allow device access again */ 1868 snd_hda_unlock_devices(bus); 1869 return 0; 1870 } 1871 1872 typedef int (*map_slave_func_t)(struct hda_codec *, void *, struct snd_kcontrol *); 1873 1874 /* apply the function to all matching slave ctls in the mixer list */ 1875 static int map_slaves(struct hda_codec *codec, const char * const *slaves, 1876 const char *suffix, map_slave_func_t func, void *data) 1877 { 1878 struct hda_nid_item *items; 1879 const char * const *s; 1880 int i, err; 1881 1882 items = codec->mixers.list; 1883 for (i = 0; i < codec->mixers.used; i++) { 1884 struct snd_kcontrol *sctl = items[i].kctl; 1885 if (!sctl || sctl->id.iface != SNDRV_CTL_ELEM_IFACE_MIXER) 1886 continue; 1887 for (s = slaves; *s; s++) { 1888 char tmpname[sizeof(sctl->id.name)]; 1889 const char *name = *s; 1890 if (suffix) { 1891 snprintf(tmpname, sizeof(tmpname), "%s %s", 1892 name, suffix); 1893 name = tmpname; 1894 } 1895 if (!strcmp(sctl->id.name, name)) { 1896 err = func(codec, data, sctl); 1897 if (err) 1898 return err; 1899 break; 1900 } 1901 } 1902 } 1903 return 0; 1904 } 1905 1906 static int check_slave_present(struct hda_codec *codec, 1907 void *data, struct snd_kcontrol *sctl) 1908 { 1909 return 1; 1910 } 1911 1912 /* guess the value corresponding to 0dB */ 1913 static int get_kctl_0dB_offset(struct hda_codec *codec, 1914 struct snd_kcontrol *kctl, int *step_to_check) 1915 { 1916 int _tlv[4]; 1917 const int *tlv = NULL; 1918 int val = -1; 1919 1920 if (kctl->vd[0].access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK) { 1921 /* FIXME: set_fs() hack for obtaining user-space TLV data */ 1922 mm_segment_t fs = get_fs(); 1923 set_fs(get_ds()); 1924 if (!kctl->tlv.c(kctl, 0, sizeof(_tlv), _tlv)) 1925 tlv = _tlv; 1926 set_fs(fs); 1927 } else if (kctl->vd[0].access & SNDRV_CTL_ELEM_ACCESS_TLV_READ) 1928 tlv = kctl->tlv.p; 1929 if (tlv && tlv[0] == SNDRV_CTL_TLVT_DB_SCALE) { 1930 int step = tlv[3]; 1931 step &= ~TLV_DB_SCALE_MUTE; 1932 if (!step) 1933 return -1; 1934 if (*step_to_check && *step_to_check != step) { 1935 codec_err(codec, "Mismatching dB step for vmaster slave (%d!=%d)\n", 1936 - *step_to_check, step); 1937 return -1; 1938 } 1939 *step_to_check = step; 1940 val = -tlv[2] / step; 1941 } 1942 return val; 1943 } 1944 1945 /* call kctl->put with the given value(s) */ 1946 static int put_kctl_with_value(struct snd_kcontrol *kctl, int val) 1947 { 1948 struct snd_ctl_elem_value *ucontrol; 1949 ucontrol = kzalloc(sizeof(*ucontrol), GFP_KERNEL); 1950 if (!ucontrol) 1951 return -ENOMEM; 1952 ucontrol->value.integer.value[0] = val; 1953 ucontrol->value.integer.value[1] = val; 1954 kctl->put(kctl, ucontrol); 1955 kfree(ucontrol); 1956 return 0; 1957 } 1958 1959 /* initialize the slave volume with 0dB */ 1960 static int init_slave_0dB(struct hda_codec *codec, 1961 void *data, struct snd_kcontrol *slave) 1962 { 1963 int offset = get_kctl_0dB_offset(codec, slave, data); 1964 if (offset > 0) 1965 put_kctl_with_value(slave, offset); 1966 return 0; 1967 } 1968 1969 /* unmute the slave */ 1970 static int init_slave_unmute(struct hda_codec *codec, 1971 void *data, struct snd_kcontrol *slave) 1972 { 1973 return put_kctl_with_value(slave, 1); 1974 } 1975 1976 static int add_slave(struct hda_codec *codec, 1977 void *data, struct snd_kcontrol *slave) 1978 { 1979 return snd_ctl_add_slave(data, slave); 1980 } 1981 1982 /** 1983 * __snd_hda_add_vmaster - create a virtual master control and add slaves 1984 * @codec: HD-audio codec 1985 * @name: vmaster control name 1986 * @tlv: TLV data (optional) 1987 * @slaves: slave control names (optional) 1988 * @suffix: suffix string to each slave name (optional) 1989 * @init_slave_vol: initialize slaves to unmute/0dB 1990 * @ctl_ret: store the vmaster kcontrol in return 1991 * 1992 * Create a virtual master control with the given name. The TLV data 1993 * must be either NULL or a valid data. 1994 * 1995 * @slaves is a NULL-terminated array of strings, each of which is a 1996 * slave control name. All controls with these names are assigned to 1997 * the new virtual master control. 1998 * 1999 * This function returns zero if successful or a negative error code. 2000 */ 2001 int __snd_hda_add_vmaster(struct hda_codec *codec, char *name, 2002 unsigned int *tlv, const char * const *slaves, 2003 const char *suffix, bool init_slave_vol, 2004 struct snd_kcontrol **ctl_ret) 2005 { 2006 struct snd_kcontrol *kctl; 2007 int err; 2008 2009 if (ctl_ret) 2010 *ctl_ret = NULL; 2011 2012 err = map_slaves(codec, slaves, suffix, check_slave_present, NULL); 2013 if (err != 1) { 2014 codec_dbg(codec, "No slave found for %s\n", name); 2015 return 0; 2016 } 2017 kctl = snd_ctl_make_virtual_master(name, tlv); 2018 if (!kctl) 2019 return -ENOMEM; 2020 err = snd_hda_ctl_add(codec, 0, kctl); 2021 if (err < 0) 2022 return err; 2023 2024 err = map_slaves(codec, slaves, suffix, add_slave, kctl); 2025 if (err < 0) 2026 return err; 2027 2028 /* init with master mute & zero volume */ 2029 put_kctl_with_value(kctl, 0); 2030 if (init_slave_vol) { 2031 int step = 0; 2032 map_slaves(codec, slaves, suffix, 2033 tlv ? init_slave_0dB : init_slave_unmute, &step); 2034 } 2035 2036 if (ctl_ret) 2037 *ctl_ret = kctl; 2038 return 0; 2039 } 2040 EXPORT_SYMBOL_GPL(__snd_hda_add_vmaster); 2041 2042 /* 2043 * mute-LED control using vmaster 2044 */ 2045 static int vmaster_mute_mode_info(struct snd_kcontrol *kcontrol, 2046 struct snd_ctl_elem_info *uinfo) 2047 { 2048 static const char * const texts[] = { 2049 "On", "Off", "Follow Master" 2050 }; 2051 2052 return snd_ctl_enum_info(uinfo, 1, 3, texts); 2053 } 2054 2055 static int vmaster_mute_mode_get(struct snd_kcontrol *kcontrol, 2056 struct snd_ctl_elem_value *ucontrol) 2057 { 2058 struct hda_vmaster_mute_hook *hook = snd_kcontrol_chip(kcontrol); 2059 ucontrol->value.enumerated.item[0] = hook->mute_mode; 2060 return 0; 2061 } 2062 2063 static int vmaster_mute_mode_put(struct snd_kcontrol *kcontrol, 2064 struct snd_ctl_elem_value *ucontrol) 2065 { 2066 struct hda_vmaster_mute_hook *hook = snd_kcontrol_chip(kcontrol); 2067 unsigned int old_mode = hook->mute_mode; 2068 2069 hook->mute_mode = ucontrol->value.enumerated.item[0]; 2070 if (hook->mute_mode > HDA_VMUTE_FOLLOW_MASTER) 2071 hook->mute_mode = HDA_VMUTE_FOLLOW_MASTER; 2072 if (old_mode == hook->mute_mode) 2073 return 0; 2074 snd_hda_sync_vmaster_hook(hook); 2075 return 1; 2076 } 2077 2078 static struct snd_kcontrol_new vmaster_mute_mode = { 2079 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2080 .name = "Mute-LED Mode", 2081 .info = vmaster_mute_mode_info, 2082 .get = vmaster_mute_mode_get, 2083 .put = vmaster_mute_mode_put, 2084 }; 2085 2086 /* meta hook to call each driver's vmaster hook */ 2087 static void vmaster_hook(void *private_data, int enabled) 2088 { 2089 struct hda_vmaster_mute_hook *hook = private_data; 2090 2091 if (hook->mute_mode != HDA_VMUTE_FOLLOW_MASTER) 2092 enabled = hook->mute_mode; 2093 hook->hook(hook->codec, enabled); 2094 } 2095 2096 /** 2097 * snd_hda_add_vmaster_hook - Add a vmaster hook for mute-LED 2098 * @codec: the HDA codec 2099 * @hook: the vmaster hook object 2100 * @expose_enum_ctl: flag to create an enum ctl 2101 * 2102 * Add a mute-LED hook with the given vmaster switch kctl. 2103 * When @expose_enum_ctl is set, "Mute-LED Mode" control is automatically 2104 * created and associated with the given hook. 2105 */ 2106 int snd_hda_add_vmaster_hook(struct hda_codec *codec, 2107 struct hda_vmaster_mute_hook *hook, 2108 bool expose_enum_ctl) 2109 { 2110 struct snd_kcontrol *kctl; 2111 2112 if (!hook->hook || !hook->sw_kctl) 2113 return 0; 2114 hook->codec = codec; 2115 hook->mute_mode = HDA_VMUTE_FOLLOW_MASTER; 2116 snd_ctl_add_vmaster_hook(hook->sw_kctl, vmaster_hook, hook); 2117 if (!expose_enum_ctl) 2118 return 0; 2119 kctl = snd_ctl_new1(&vmaster_mute_mode, hook); 2120 if (!kctl) 2121 return -ENOMEM; 2122 return snd_hda_ctl_add(codec, 0, kctl); 2123 } 2124 EXPORT_SYMBOL_GPL(snd_hda_add_vmaster_hook); 2125 2126 /** 2127 * snd_hda_sync_vmaster_hook - Sync vmaster hook 2128 * @hook: the vmaster hook 2129 * 2130 * Call the hook with the current value for synchronization. 2131 * Should be called in init callback. 2132 */ 2133 void snd_hda_sync_vmaster_hook(struct hda_vmaster_mute_hook *hook) 2134 { 2135 if (!hook->hook || !hook->codec) 2136 return; 2137 /* don't call vmaster hook in the destructor since it might have 2138 * been already destroyed 2139 */ 2140 if (hook->codec->bus->shutdown) 2141 return; 2142 snd_ctl_sync_vmaster_hook(hook->sw_kctl); 2143 } 2144 EXPORT_SYMBOL_GPL(snd_hda_sync_vmaster_hook); 2145 2146 2147 /** 2148 * snd_hda_mixer_amp_switch_info - Info callback for a standard AMP mixer switch 2149 * @kcontrol: referred ctl element 2150 * @uinfo: pointer to get/store the data 2151 * 2152 * The control element is supposed to have the private_value field 2153 * set up via HDA_COMPOSE_AMP_VAL*() or related macros. 2154 */ 2155 int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol, 2156 struct snd_ctl_elem_info *uinfo) 2157 { 2158 int chs = get_amp_channels(kcontrol); 2159 2160 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; 2161 uinfo->count = chs == 3 ? 2 : 1; 2162 uinfo->value.integer.min = 0; 2163 uinfo->value.integer.max = 1; 2164 return 0; 2165 } 2166 EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_switch_info); 2167 2168 /** 2169 * snd_hda_mixer_amp_switch_get - Get callback for a standard AMP mixer switch 2170 * @kcontrol: ctl element 2171 * @ucontrol: pointer to get/store the data 2172 * 2173 * The control element is supposed to have the private_value field 2174 * set up via HDA_COMPOSE_AMP_VAL*() or related macros. 2175 */ 2176 int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol, 2177 struct snd_ctl_elem_value *ucontrol) 2178 { 2179 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2180 hda_nid_t nid = get_amp_nid(kcontrol); 2181 int chs = get_amp_channels(kcontrol); 2182 int dir = get_amp_direction(kcontrol); 2183 int idx = get_amp_index(kcontrol); 2184 long *valp = ucontrol->value.integer.value; 2185 2186 if (chs & 1) 2187 *valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) & 2188 HDA_AMP_MUTE) ? 0 : 1; 2189 if (chs & 2) 2190 *valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) & 2191 HDA_AMP_MUTE) ? 0 : 1; 2192 return 0; 2193 } 2194 EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_switch_get); 2195 2196 /** 2197 * snd_hda_mixer_amp_switch_put - Put callback for a standard AMP mixer switch 2198 * @kcontrol: ctl element 2199 * @ucontrol: pointer to get/store the data 2200 * 2201 * The control element is supposed to have the private_value field 2202 * set up via HDA_COMPOSE_AMP_VAL*() or related macros. 2203 */ 2204 int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol, 2205 struct snd_ctl_elem_value *ucontrol) 2206 { 2207 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2208 hda_nid_t nid = get_amp_nid(kcontrol); 2209 int chs = get_amp_channels(kcontrol); 2210 int dir = get_amp_direction(kcontrol); 2211 int idx = get_amp_index(kcontrol); 2212 long *valp = ucontrol->value.integer.value; 2213 int change = 0; 2214 2215 if (chs & 1) { 2216 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx, 2217 HDA_AMP_MUTE, 2218 *valp ? 0 : HDA_AMP_MUTE); 2219 valp++; 2220 } 2221 if (chs & 2) 2222 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx, 2223 HDA_AMP_MUTE, 2224 *valp ? 0 : HDA_AMP_MUTE); 2225 hda_call_check_power_status(codec, nid); 2226 return change; 2227 } 2228 EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_switch_put); 2229 2230 /* 2231 * bound volume controls 2232 * 2233 * bind multiple volumes (# indices, from 0) 2234 */ 2235 2236 #define AMP_VAL_IDX_SHIFT 19 2237 #define AMP_VAL_IDX_MASK (0x0f<<19) 2238 2239 /** 2240 * snd_hda_mixer_bind_switch_get - Get callback for a bound volume control 2241 * @kcontrol: ctl element 2242 * @ucontrol: pointer to get/store the data 2243 * 2244 * The control element is supposed to have the private_value field 2245 * set up via HDA_BIND_MUTE*() macros. 2246 */ 2247 int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol, 2248 struct snd_ctl_elem_value *ucontrol) 2249 { 2250 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2251 unsigned long pval; 2252 int err; 2253 2254 mutex_lock(&codec->control_mutex); 2255 pval = kcontrol->private_value; 2256 kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */ 2257 err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol); 2258 kcontrol->private_value = pval; 2259 mutex_unlock(&codec->control_mutex); 2260 return err; 2261 } 2262 EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_switch_get); 2263 2264 /** 2265 * snd_hda_mixer_bind_switch_put - Put callback for a bound volume control 2266 * @kcontrol: ctl element 2267 * @ucontrol: pointer to get/store the data 2268 * 2269 * The control element is supposed to have the private_value field 2270 * set up via HDA_BIND_MUTE*() macros. 2271 */ 2272 int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol, 2273 struct snd_ctl_elem_value *ucontrol) 2274 { 2275 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2276 unsigned long pval; 2277 int i, indices, err = 0, change = 0; 2278 2279 mutex_lock(&codec->control_mutex); 2280 pval = kcontrol->private_value; 2281 indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT; 2282 for (i = 0; i < indices; i++) { 2283 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) | 2284 (i << AMP_VAL_IDX_SHIFT); 2285 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol); 2286 if (err < 0) 2287 break; 2288 change |= err; 2289 } 2290 kcontrol->private_value = pval; 2291 mutex_unlock(&codec->control_mutex); 2292 return err < 0 ? err : change; 2293 } 2294 EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_switch_put); 2295 2296 /** 2297 * snd_hda_mixer_bind_ctls_info - Info callback for a generic bound control 2298 * @kcontrol: referred ctl element 2299 * @uinfo: pointer to get/store the data 2300 * 2301 * The control element is supposed to have the private_value field 2302 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros. 2303 */ 2304 int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol, 2305 struct snd_ctl_elem_info *uinfo) 2306 { 2307 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2308 struct hda_bind_ctls *c; 2309 int err; 2310 2311 mutex_lock(&codec->control_mutex); 2312 c = (struct hda_bind_ctls *)kcontrol->private_value; 2313 kcontrol->private_value = *c->values; 2314 err = c->ops->info(kcontrol, uinfo); 2315 kcontrol->private_value = (long)c; 2316 mutex_unlock(&codec->control_mutex); 2317 return err; 2318 } 2319 EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_ctls_info); 2320 2321 /** 2322 * snd_hda_mixer_bind_ctls_get - Get callback for a generic bound control 2323 * @kcontrol: ctl element 2324 * @ucontrol: pointer to get/store the data 2325 * 2326 * The control element is supposed to have the private_value field 2327 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros. 2328 */ 2329 int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol, 2330 struct snd_ctl_elem_value *ucontrol) 2331 { 2332 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2333 struct hda_bind_ctls *c; 2334 int err; 2335 2336 mutex_lock(&codec->control_mutex); 2337 c = (struct hda_bind_ctls *)kcontrol->private_value; 2338 kcontrol->private_value = *c->values; 2339 err = c->ops->get(kcontrol, ucontrol); 2340 kcontrol->private_value = (long)c; 2341 mutex_unlock(&codec->control_mutex); 2342 return err; 2343 } 2344 EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_ctls_get); 2345 2346 /** 2347 * snd_hda_mixer_bind_ctls_put - Put callback for a generic bound control 2348 * @kcontrol: ctl element 2349 * @ucontrol: pointer to get/store the data 2350 * 2351 * The control element is supposed to have the private_value field 2352 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros. 2353 */ 2354 int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol, 2355 struct snd_ctl_elem_value *ucontrol) 2356 { 2357 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2358 struct hda_bind_ctls *c; 2359 unsigned long *vals; 2360 int err = 0, change = 0; 2361 2362 mutex_lock(&codec->control_mutex); 2363 c = (struct hda_bind_ctls *)kcontrol->private_value; 2364 for (vals = c->values; *vals; vals++) { 2365 kcontrol->private_value = *vals; 2366 err = c->ops->put(kcontrol, ucontrol); 2367 if (err < 0) 2368 break; 2369 change |= err; 2370 } 2371 kcontrol->private_value = (long)c; 2372 mutex_unlock(&codec->control_mutex); 2373 return err < 0 ? err : change; 2374 } 2375 EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_ctls_put); 2376 2377 /** 2378 * snd_hda_mixer_bind_tlv - TLV callback for a generic bound control 2379 * @kcontrol: ctl element 2380 * @op_flag: operation flag 2381 * @size: byte size of input TLV 2382 * @tlv: TLV data 2383 * 2384 * The control element is supposed to have the private_value field 2385 * set up via HDA_BIND_VOL() macro. 2386 */ 2387 int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag, 2388 unsigned int size, unsigned int __user *tlv) 2389 { 2390 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2391 struct hda_bind_ctls *c; 2392 int err; 2393 2394 mutex_lock(&codec->control_mutex); 2395 c = (struct hda_bind_ctls *)kcontrol->private_value; 2396 kcontrol->private_value = *c->values; 2397 err = c->ops->tlv(kcontrol, op_flag, size, tlv); 2398 kcontrol->private_value = (long)c; 2399 mutex_unlock(&codec->control_mutex); 2400 return err; 2401 } 2402 EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_tlv); 2403 2404 struct hda_ctl_ops snd_hda_bind_vol = { 2405 .info = snd_hda_mixer_amp_volume_info, 2406 .get = snd_hda_mixer_amp_volume_get, 2407 .put = snd_hda_mixer_amp_volume_put, 2408 .tlv = snd_hda_mixer_amp_tlv 2409 }; 2410 EXPORT_SYMBOL_GPL(snd_hda_bind_vol); 2411 2412 struct hda_ctl_ops snd_hda_bind_sw = { 2413 .info = snd_hda_mixer_amp_switch_info, 2414 .get = snd_hda_mixer_amp_switch_get, 2415 .put = snd_hda_mixer_amp_switch_put, 2416 .tlv = snd_hda_mixer_amp_tlv 2417 }; 2418 EXPORT_SYMBOL_GPL(snd_hda_bind_sw); 2419 2420 /* 2421 * SPDIF out controls 2422 */ 2423 2424 static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol, 2425 struct snd_ctl_elem_info *uinfo) 2426 { 2427 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; 2428 uinfo->count = 1; 2429 return 0; 2430 } 2431 2432 static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol, 2433 struct snd_ctl_elem_value *ucontrol) 2434 { 2435 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL | 2436 IEC958_AES0_NONAUDIO | 2437 IEC958_AES0_CON_EMPHASIS_5015 | 2438 IEC958_AES0_CON_NOT_COPYRIGHT; 2439 ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY | 2440 IEC958_AES1_CON_ORIGINAL; 2441 return 0; 2442 } 2443 2444 static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol, 2445 struct snd_ctl_elem_value *ucontrol) 2446 { 2447 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL | 2448 IEC958_AES0_NONAUDIO | 2449 IEC958_AES0_PRO_EMPHASIS_5015; 2450 return 0; 2451 } 2452 2453 static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol, 2454 struct snd_ctl_elem_value *ucontrol) 2455 { 2456 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2457 int idx = kcontrol->private_value; 2458 struct hda_spdif_out *spdif; 2459 2460 mutex_lock(&codec->spdif_mutex); 2461 spdif = snd_array_elem(&codec->spdif_out, idx); 2462 ucontrol->value.iec958.status[0] = spdif->status & 0xff; 2463 ucontrol->value.iec958.status[1] = (spdif->status >> 8) & 0xff; 2464 ucontrol->value.iec958.status[2] = (spdif->status >> 16) & 0xff; 2465 ucontrol->value.iec958.status[3] = (spdif->status >> 24) & 0xff; 2466 mutex_unlock(&codec->spdif_mutex); 2467 2468 return 0; 2469 } 2470 2471 /* convert from SPDIF status bits to HDA SPDIF bits 2472 * bit 0 (DigEn) is always set zero (to be filled later) 2473 */ 2474 static unsigned short convert_from_spdif_status(unsigned int sbits) 2475 { 2476 unsigned short val = 0; 2477 2478 if (sbits & IEC958_AES0_PROFESSIONAL) 2479 val |= AC_DIG1_PROFESSIONAL; 2480 if (sbits & IEC958_AES0_NONAUDIO) 2481 val |= AC_DIG1_NONAUDIO; 2482 if (sbits & IEC958_AES0_PROFESSIONAL) { 2483 if ((sbits & IEC958_AES0_PRO_EMPHASIS) == 2484 IEC958_AES0_PRO_EMPHASIS_5015) 2485 val |= AC_DIG1_EMPHASIS; 2486 } else { 2487 if ((sbits & IEC958_AES0_CON_EMPHASIS) == 2488 IEC958_AES0_CON_EMPHASIS_5015) 2489 val |= AC_DIG1_EMPHASIS; 2490 if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT)) 2491 val |= AC_DIG1_COPYRIGHT; 2492 if (sbits & (IEC958_AES1_CON_ORIGINAL << 8)) 2493 val |= AC_DIG1_LEVEL; 2494 val |= sbits & (IEC958_AES1_CON_CATEGORY << 8); 2495 } 2496 return val; 2497 } 2498 2499 /* convert to SPDIF status bits from HDA SPDIF bits 2500 */ 2501 static unsigned int convert_to_spdif_status(unsigned short val) 2502 { 2503 unsigned int sbits = 0; 2504 2505 if (val & AC_DIG1_NONAUDIO) 2506 sbits |= IEC958_AES0_NONAUDIO; 2507 if (val & AC_DIG1_PROFESSIONAL) 2508 sbits |= IEC958_AES0_PROFESSIONAL; 2509 if (sbits & IEC958_AES0_PROFESSIONAL) { 2510 if (val & AC_DIG1_EMPHASIS) 2511 sbits |= IEC958_AES0_PRO_EMPHASIS_5015; 2512 } else { 2513 if (val & AC_DIG1_EMPHASIS) 2514 sbits |= IEC958_AES0_CON_EMPHASIS_5015; 2515 if (!(val & AC_DIG1_COPYRIGHT)) 2516 sbits |= IEC958_AES0_CON_NOT_COPYRIGHT; 2517 if (val & AC_DIG1_LEVEL) 2518 sbits |= (IEC958_AES1_CON_ORIGINAL << 8); 2519 sbits |= val & (0x7f << 8); 2520 } 2521 return sbits; 2522 } 2523 2524 /* set digital convert verbs both for the given NID and its slaves */ 2525 static void set_dig_out(struct hda_codec *codec, hda_nid_t nid, 2526 int mask, int val) 2527 { 2528 const hda_nid_t *d; 2529 2530 snd_hdac_regmap_update(&codec->core, nid, AC_VERB_SET_DIGI_CONVERT_1, 2531 mask, val); 2532 d = codec->slave_dig_outs; 2533 if (!d) 2534 return; 2535 for (; *d; d++) 2536 snd_hdac_regmap_update(&codec->core, *d, 2537 AC_VERB_SET_DIGI_CONVERT_1, mask, val); 2538 } 2539 2540 static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid, 2541 int dig1, int dig2) 2542 { 2543 unsigned int mask = 0; 2544 unsigned int val = 0; 2545 2546 if (dig1 != -1) { 2547 mask |= 0xff; 2548 val = dig1; 2549 } 2550 if (dig2 != -1) { 2551 mask |= 0xff00; 2552 val |= dig2 << 8; 2553 } 2554 set_dig_out(codec, nid, mask, val); 2555 } 2556 2557 static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol, 2558 struct snd_ctl_elem_value *ucontrol) 2559 { 2560 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2561 int idx = kcontrol->private_value; 2562 struct hda_spdif_out *spdif; 2563 hda_nid_t nid; 2564 unsigned short val; 2565 int change; 2566 2567 mutex_lock(&codec->spdif_mutex); 2568 spdif = snd_array_elem(&codec->spdif_out, idx); 2569 nid = spdif->nid; 2570 spdif->status = ucontrol->value.iec958.status[0] | 2571 ((unsigned int)ucontrol->value.iec958.status[1] << 8) | 2572 ((unsigned int)ucontrol->value.iec958.status[2] << 16) | 2573 ((unsigned int)ucontrol->value.iec958.status[3] << 24); 2574 val = convert_from_spdif_status(spdif->status); 2575 val |= spdif->ctls & 1; 2576 change = spdif->ctls != val; 2577 spdif->ctls = val; 2578 if (change && nid != (u16)-1) 2579 set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff); 2580 mutex_unlock(&codec->spdif_mutex); 2581 return change; 2582 } 2583 2584 #define snd_hda_spdif_out_switch_info snd_ctl_boolean_mono_info 2585 2586 static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol, 2587 struct snd_ctl_elem_value *ucontrol) 2588 { 2589 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2590 int idx = kcontrol->private_value; 2591 struct hda_spdif_out *spdif; 2592 2593 mutex_lock(&codec->spdif_mutex); 2594 spdif = snd_array_elem(&codec->spdif_out, idx); 2595 ucontrol->value.integer.value[0] = spdif->ctls & AC_DIG1_ENABLE; 2596 mutex_unlock(&codec->spdif_mutex); 2597 return 0; 2598 } 2599 2600 static inline void set_spdif_ctls(struct hda_codec *codec, hda_nid_t nid, 2601 int dig1, int dig2) 2602 { 2603 set_dig_out_convert(codec, nid, dig1, dig2); 2604 /* unmute amp switch (if any) */ 2605 if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) && 2606 (dig1 & AC_DIG1_ENABLE)) 2607 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0, 2608 HDA_AMP_MUTE, 0); 2609 } 2610 2611 static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol, 2612 struct snd_ctl_elem_value *ucontrol) 2613 { 2614 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2615 int idx = kcontrol->private_value; 2616 struct hda_spdif_out *spdif; 2617 hda_nid_t nid; 2618 unsigned short val; 2619 int change; 2620 2621 mutex_lock(&codec->spdif_mutex); 2622 spdif = snd_array_elem(&codec->spdif_out, idx); 2623 nid = spdif->nid; 2624 val = spdif->ctls & ~AC_DIG1_ENABLE; 2625 if (ucontrol->value.integer.value[0]) 2626 val |= AC_DIG1_ENABLE; 2627 change = spdif->ctls != val; 2628 spdif->ctls = val; 2629 if (change && nid != (u16)-1) 2630 set_spdif_ctls(codec, nid, val & 0xff, -1); 2631 mutex_unlock(&codec->spdif_mutex); 2632 return change; 2633 } 2634 2635 static struct snd_kcontrol_new dig_mixes[] = { 2636 { 2637 .access = SNDRV_CTL_ELEM_ACCESS_READ, 2638 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2639 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, CON_MASK), 2640 .info = snd_hda_spdif_mask_info, 2641 .get = snd_hda_spdif_cmask_get, 2642 }, 2643 { 2644 .access = SNDRV_CTL_ELEM_ACCESS_READ, 2645 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2646 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, PRO_MASK), 2647 .info = snd_hda_spdif_mask_info, 2648 .get = snd_hda_spdif_pmask_get, 2649 }, 2650 { 2651 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2652 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT), 2653 .info = snd_hda_spdif_mask_info, 2654 .get = snd_hda_spdif_default_get, 2655 .put = snd_hda_spdif_default_put, 2656 }, 2657 { 2658 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2659 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH), 2660 .info = snd_hda_spdif_out_switch_info, 2661 .get = snd_hda_spdif_out_switch_get, 2662 .put = snd_hda_spdif_out_switch_put, 2663 }, 2664 { } /* end */ 2665 }; 2666 2667 /** 2668 * snd_hda_create_dig_out_ctls - create Output SPDIF-related controls 2669 * @codec: the HDA codec 2670 * @associated_nid: NID that new ctls associated with 2671 * @cvt_nid: converter NID 2672 * @type: HDA_PCM_TYPE_* 2673 * Creates controls related with the digital output. 2674 * Called from each patch supporting the digital out. 2675 * 2676 * Returns 0 if successful, or a negative error code. 2677 */ 2678 int snd_hda_create_dig_out_ctls(struct hda_codec *codec, 2679 hda_nid_t associated_nid, 2680 hda_nid_t cvt_nid, 2681 int type) 2682 { 2683 int err; 2684 struct snd_kcontrol *kctl; 2685 struct snd_kcontrol_new *dig_mix; 2686 int idx = 0; 2687 int val = 0; 2688 const int spdif_index = 16; 2689 struct hda_spdif_out *spdif; 2690 struct hda_bus *bus = codec->bus; 2691 2692 if (bus->primary_dig_out_type == HDA_PCM_TYPE_HDMI && 2693 type == HDA_PCM_TYPE_SPDIF) { 2694 idx = spdif_index; 2695 } else if (bus->primary_dig_out_type == HDA_PCM_TYPE_SPDIF && 2696 type == HDA_PCM_TYPE_HDMI) { 2697 /* suppose a single SPDIF device */ 2698 for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) { 2699 kctl = find_mixer_ctl(codec, dig_mix->name, 0, 0); 2700 if (!kctl) 2701 break; 2702 kctl->id.index = spdif_index; 2703 } 2704 bus->primary_dig_out_type = HDA_PCM_TYPE_HDMI; 2705 } 2706 if (!bus->primary_dig_out_type) 2707 bus->primary_dig_out_type = type; 2708 2709 idx = find_empty_mixer_ctl_idx(codec, "IEC958 Playback Switch", idx); 2710 if (idx < 0) { 2711 codec_err(codec, "too many IEC958 outputs\n"); 2712 return -EBUSY; 2713 } 2714 spdif = snd_array_new(&codec->spdif_out); 2715 if (!spdif) 2716 return -ENOMEM; 2717 for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) { 2718 kctl = snd_ctl_new1(dig_mix, codec); 2719 if (!kctl) 2720 return -ENOMEM; 2721 kctl->id.index = idx; 2722 kctl->private_value = codec->spdif_out.used - 1; 2723 err = snd_hda_ctl_add(codec, associated_nid, kctl); 2724 if (err < 0) 2725 return err; 2726 } 2727 spdif->nid = cvt_nid; 2728 snd_hdac_regmap_read(&codec->core, cvt_nid, 2729 AC_VERB_GET_DIGI_CONVERT_1, &val); 2730 spdif->ctls = val; 2731 spdif->status = convert_to_spdif_status(spdif->ctls); 2732 return 0; 2733 } 2734 EXPORT_SYMBOL_GPL(snd_hda_create_dig_out_ctls); 2735 2736 /** 2737 * snd_hda_spdif_out_of_nid - get the hda_spdif_out entry from the given NID 2738 * @codec: the HDA codec 2739 * @nid: widget NID 2740 * 2741 * call within spdif_mutex lock 2742 */ 2743 struct hda_spdif_out *snd_hda_spdif_out_of_nid(struct hda_codec *codec, 2744 hda_nid_t nid) 2745 { 2746 int i; 2747 for (i = 0; i < codec->spdif_out.used; i++) { 2748 struct hda_spdif_out *spdif = 2749 snd_array_elem(&codec->spdif_out, i); 2750 if (spdif->nid == nid) 2751 return spdif; 2752 } 2753 return NULL; 2754 } 2755 EXPORT_SYMBOL_GPL(snd_hda_spdif_out_of_nid); 2756 2757 /** 2758 * snd_hda_spdif_ctls_unassign - Unassign the given SPDIF ctl 2759 * @codec: the HDA codec 2760 * @idx: the SPDIF ctl index 2761 * 2762 * Unassign the widget from the given SPDIF control. 2763 */ 2764 void snd_hda_spdif_ctls_unassign(struct hda_codec *codec, int idx) 2765 { 2766 struct hda_spdif_out *spdif; 2767 2768 mutex_lock(&codec->spdif_mutex); 2769 spdif = snd_array_elem(&codec->spdif_out, idx); 2770 spdif->nid = (u16)-1; 2771 mutex_unlock(&codec->spdif_mutex); 2772 } 2773 EXPORT_SYMBOL_GPL(snd_hda_spdif_ctls_unassign); 2774 2775 /** 2776 * snd_hda_spdif_ctls_assign - Assign the SPDIF controls to the given NID 2777 * @codec: the HDA codec 2778 * @idx: the SPDIF ctl idx 2779 * @nid: widget NID 2780 * 2781 * Assign the widget to the SPDIF control with the given index. 2782 */ 2783 void snd_hda_spdif_ctls_assign(struct hda_codec *codec, int idx, hda_nid_t nid) 2784 { 2785 struct hda_spdif_out *spdif; 2786 unsigned short val; 2787 2788 mutex_lock(&codec->spdif_mutex); 2789 spdif = snd_array_elem(&codec->spdif_out, idx); 2790 if (spdif->nid != nid) { 2791 spdif->nid = nid; 2792 val = spdif->ctls; 2793 set_spdif_ctls(codec, nid, val & 0xff, (val >> 8) & 0xff); 2794 } 2795 mutex_unlock(&codec->spdif_mutex); 2796 } 2797 EXPORT_SYMBOL_GPL(snd_hda_spdif_ctls_assign); 2798 2799 /* 2800 * SPDIF sharing with analog output 2801 */ 2802 static int spdif_share_sw_get(struct snd_kcontrol *kcontrol, 2803 struct snd_ctl_elem_value *ucontrol) 2804 { 2805 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol); 2806 ucontrol->value.integer.value[0] = mout->share_spdif; 2807 return 0; 2808 } 2809 2810 static int spdif_share_sw_put(struct snd_kcontrol *kcontrol, 2811 struct snd_ctl_elem_value *ucontrol) 2812 { 2813 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol); 2814 mout->share_spdif = !!ucontrol->value.integer.value[0]; 2815 return 0; 2816 } 2817 2818 static struct snd_kcontrol_new spdif_share_sw = { 2819 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2820 .name = "IEC958 Default PCM Playback Switch", 2821 .info = snd_ctl_boolean_mono_info, 2822 .get = spdif_share_sw_get, 2823 .put = spdif_share_sw_put, 2824 }; 2825 2826 /** 2827 * snd_hda_create_spdif_share_sw - create Default PCM switch 2828 * @codec: the HDA codec 2829 * @mout: multi-out instance 2830 */ 2831 int snd_hda_create_spdif_share_sw(struct hda_codec *codec, 2832 struct hda_multi_out *mout) 2833 { 2834 struct snd_kcontrol *kctl; 2835 2836 if (!mout->dig_out_nid) 2837 return 0; 2838 2839 kctl = snd_ctl_new1(&spdif_share_sw, mout); 2840 if (!kctl) 2841 return -ENOMEM; 2842 /* ATTENTION: here mout is passed as private_data, instead of codec */ 2843 return snd_hda_ctl_add(codec, mout->dig_out_nid, kctl); 2844 } 2845 EXPORT_SYMBOL_GPL(snd_hda_create_spdif_share_sw); 2846 2847 /* 2848 * SPDIF input 2849 */ 2850 2851 #define snd_hda_spdif_in_switch_info snd_hda_spdif_out_switch_info 2852 2853 static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol, 2854 struct snd_ctl_elem_value *ucontrol) 2855 { 2856 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2857 2858 ucontrol->value.integer.value[0] = codec->spdif_in_enable; 2859 return 0; 2860 } 2861 2862 static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol, 2863 struct snd_ctl_elem_value *ucontrol) 2864 { 2865 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2866 hda_nid_t nid = kcontrol->private_value; 2867 unsigned int val = !!ucontrol->value.integer.value[0]; 2868 int change; 2869 2870 mutex_lock(&codec->spdif_mutex); 2871 change = codec->spdif_in_enable != val; 2872 if (change) { 2873 codec->spdif_in_enable = val; 2874 snd_hdac_regmap_write(&codec->core, nid, 2875 AC_VERB_SET_DIGI_CONVERT_1, val); 2876 } 2877 mutex_unlock(&codec->spdif_mutex); 2878 return change; 2879 } 2880 2881 static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol, 2882 struct snd_ctl_elem_value *ucontrol) 2883 { 2884 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2885 hda_nid_t nid = kcontrol->private_value; 2886 unsigned int val; 2887 unsigned int sbits; 2888 2889 snd_hdac_regmap_read(&codec->core, nid, 2890 AC_VERB_GET_DIGI_CONVERT_1, &val); 2891 sbits = convert_to_spdif_status(val); 2892 ucontrol->value.iec958.status[0] = sbits; 2893 ucontrol->value.iec958.status[1] = sbits >> 8; 2894 ucontrol->value.iec958.status[2] = sbits >> 16; 2895 ucontrol->value.iec958.status[3] = sbits >> 24; 2896 return 0; 2897 } 2898 2899 static struct snd_kcontrol_new dig_in_ctls[] = { 2900 { 2901 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2902 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, SWITCH), 2903 .info = snd_hda_spdif_in_switch_info, 2904 .get = snd_hda_spdif_in_switch_get, 2905 .put = snd_hda_spdif_in_switch_put, 2906 }, 2907 { 2908 .access = SNDRV_CTL_ELEM_ACCESS_READ, 2909 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2910 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, DEFAULT), 2911 .info = snd_hda_spdif_mask_info, 2912 .get = snd_hda_spdif_in_status_get, 2913 }, 2914 { } /* end */ 2915 }; 2916 2917 /** 2918 * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls 2919 * @codec: the HDA codec 2920 * @nid: audio in widget NID 2921 * 2922 * Creates controls related with the SPDIF input. 2923 * Called from each patch supporting the SPDIF in. 2924 * 2925 * Returns 0 if successful, or a negative error code. 2926 */ 2927 int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid) 2928 { 2929 int err; 2930 struct snd_kcontrol *kctl; 2931 struct snd_kcontrol_new *dig_mix; 2932 int idx; 2933 2934 idx = find_empty_mixer_ctl_idx(codec, "IEC958 Capture Switch", 0); 2935 if (idx < 0) { 2936 codec_err(codec, "too many IEC958 inputs\n"); 2937 return -EBUSY; 2938 } 2939 for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) { 2940 kctl = snd_ctl_new1(dig_mix, codec); 2941 if (!kctl) 2942 return -ENOMEM; 2943 kctl->private_value = nid; 2944 err = snd_hda_ctl_add(codec, nid, kctl); 2945 if (err < 0) 2946 return err; 2947 } 2948 codec->spdif_in_enable = 2949 snd_hda_codec_read(codec, nid, 0, 2950 AC_VERB_GET_DIGI_CONVERT_1, 0) & 2951 AC_DIG1_ENABLE; 2952 return 0; 2953 } 2954 EXPORT_SYMBOL_GPL(snd_hda_create_spdif_in_ctls); 2955 2956 /** 2957 * snd_hda_codec_set_power_to_all - Set the power state to all widgets 2958 * @codec: the HDA codec 2959 * @fg: function group (not used now) 2960 * @power_state: the power state to set (AC_PWRST_*) 2961 * 2962 * Set the given power state to all widgets that have the power control. 2963 * If the codec has power_filter set, it evaluates the power state and 2964 * filter out if it's unchanged as D3. 2965 */ 2966 void snd_hda_codec_set_power_to_all(struct hda_codec *codec, hda_nid_t fg, 2967 unsigned int power_state) 2968 { 2969 hda_nid_t nid; 2970 2971 for_each_hda_codec_node(nid, codec) { 2972 unsigned int wcaps = get_wcaps(codec, nid); 2973 unsigned int state = power_state; 2974 if (!(wcaps & AC_WCAP_POWER)) 2975 continue; 2976 if (codec->power_filter) { 2977 state = codec->power_filter(codec, nid, power_state); 2978 if (state != power_state && power_state == AC_PWRST_D3) 2979 continue; 2980 } 2981 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_POWER_STATE, 2982 state); 2983 } 2984 } 2985 EXPORT_SYMBOL_GPL(snd_hda_codec_set_power_to_all); 2986 2987 /* 2988 * wait until the state is reached, returns the current state 2989 */ 2990 static unsigned int hda_sync_power_state(struct hda_codec *codec, 2991 hda_nid_t fg, 2992 unsigned int power_state) 2993 { 2994 unsigned long end_time = jiffies + msecs_to_jiffies(500); 2995 unsigned int state, actual_state; 2996 2997 for (;;) { 2998 state = snd_hda_codec_read(codec, fg, 0, 2999 AC_VERB_GET_POWER_STATE, 0); 3000 if (state & AC_PWRST_ERROR) 3001 break; 3002 actual_state = (state >> 4) & 0x0f; 3003 if (actual_state == power_state) 3004 break; 3005 if (time_after_eq(jiffies, end_time)) 3006 break; 3007 /* wait until the codec reachs to the target state */ 3008 msleep(1); 3009 } 3010 return state; 3011 } 3012 3013 /** 3014 * snd_hda_codec_eapd_power_filter - A power filter callback for EAPD 3015 * @codec: the HDA codec 3016 * @nid: widget NID 3017 * @power_state: power state to evalue 3018 * 3019 * Don't power down the widget if it controls eapd and EAPD_BTLENABLE is set. 3020 * This can be used a codec power_filter callback. 3021 */ 3022 unsigned int snd_hda_codec_eapd_power_filter(struct hda_codec *codec, 3023 hda_nid_t nid, 3024 unsigned int power_state) 3025 { 3026 if (nid == codec->core.afg || nid == codec->core.mfg) 3027 return power_state; 3028 if (power_state == AC_PWRST_D3 && 3029 get_wcaps_type(get_wcaps(codec, nid)) == AC_WID_PIN && 3030 (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)) { 3031 int eapd = snd_hda_codec_read(codec, nid, 0, 3032 AC_VERB_GET_EAPD_BTLENABLE, 0); 3033 if (eapd & 0x02) 3034 return AC_PWRST_D0; 3035 } 3036 return power_state; 3037 } 3038 EXPORT_SYMBOL_GPL(snd_hda_codec_eapd_power_filter); 3039 3040 /* 3041 * set power state of the codec, and return the power state 3042 */ 3043 static unsigned int hda_set_power_state(struct hda_codec *codec, 3044 unsigned int power_state) 3045 { 3046 hda_nid_t fg = codec->core.afg ? codec->core.afg : codec->core.mfg; 3047 int count; 3048 unsigned int state; 3049 int flags = 0; 3050 3051 /* this delay seems necessary to avoid click noise at power-down */ 3052 if (power_state == AC_PWRST_D3) { 3053 if (codec->depop_delay < 0) 3054 msleep(codec_has_epss(codec) ? 10 : 100); 3055 else if (codec->depop_delay > 0) 3056 msleep(codec->depop_delay); 3057 flags = HDA_RW_NO_RESPONSE_FALLBACK; 3058 } 3059 3060 /* repeat power states setting at most 10 times*/ 3061 for (count = 0; count < 10; count++) { 3062 if (codec->patch_ops.set_power_state) 3063 codec->patch_ops.set_power_state(codec, fg, 3064 power_state); 3065 else { 3066 state = power_state; 3067 if (codec->power_filter) 3068 state = codec->power_filter(codec, fg, state); 3069 if (state == power_state || power_state != AC_PWRST_D3) 3070 snd_hda_codec_read(codec, fg, flags, 3071 AC_VERB_SET_POWER_STATE, 3072 state); 3073 snd_hda_codec_set_power_to_all(codec, fg, power_state); 3074 } 3075 state = hda_sync_power_state(codec, fg, power_state); 3076 if (!(state & AC_PWRST_ERROR)) 3077 break; 3078 } 3079 3080 return state; 3081 } 3082 3083 /* sync power states of all widgets; 3084 * this is called at the end of codec parsing 3085 */ 3086 static void sync_power_up_states(struct hda_codec *codec) 3087 { 3088 hda_nid_t nid; 3089 3090 /* don't care if no filter is used */ 3091 if (!codec->power_filter) 3092 return; 3093 3094 for_each_hda_codec_node(nid, codec) { 3095 unsigned int wcaps = get_wcaps(codec, nid); 3096 unsigned int target; 3097 if (!(wcaps & AC_WCAP_POWER)) 3098 continue; 3099 target = codec->power_filter(codec, nid, AC_PWRST_D0); 3100 if (target == AC_PWRST_D0) 3101 continue; 3102 if (!snd_hda_check_power_state(codec, nid, target)) 3103 snd_hda_codec_write(codec, nid, 0, 3104 AC_VERB_SET_POWER_STATE, target); 3105 } 3106 } 3107 3108 #ifdef CONFIG_SND_HDA_RECONFIG 3109 /* execute additional init verbs */ 3110 static void hda_exec_init_verbs(struct hda_codec *codec) 3111 { 3112 if (codec->init_verbs.list) 3113 snd_hda_sequence_write(codec, codec->init_verbs.list); 3114 } 3115 #else 3116 static inline void hda_exec_init_verbs(struct hda_codec *codec) {} 3117 #endif 3118 3119 #ifdef CONFIG_PM 3120 /* update the power on/off account with the current jiffies */ 3121 static void update_power_acct(struct hda_codec *codec, bool on) 3122 { 3123 unsigned long delta = jiffies - codec->power_jiffies; 3124 3125 if (on) 3126 codec->power_on_acct += delta; 3127 else 3128 codec->power_off_acct += delta; 3129 codec->power_jiffies += delta; 3130 } 3131 3132 void snd_hda_update_power_acct(struct hda_codec *codec) 3133 { 3134 update_power_acct(codec, hda_codec_is_power_on(codec)); 3135 } 3136 3137 /* 3138 * call suspend and power-down; used both from PM and power-save 3139 * this function returns the power state in the end 3140 */ 3141 static unsigned int hda_call_codec_suspend(struct hda_codec *codec) 3142 { 3143 unsigned int state; 3144 3145 atomic_inc(&codec->core.in_pm); 3146 3147 if (codec->patch_ops.suspend) 3148 codec->patch_ops.suspend(codec); 3149 hda_cleanup_all_streams(codec); 3150 state = hda_set_power_state(codec, AC_PWRST_D3); 3151 update_power_acct(codec, true); 3152 atomic_dec(&codec->core.in_pm); 3153 return state; 3154 } 3155 3156 /* 3157 * kick up codec; used both from PM and power-save 3158 */ 3159 static void hda_call_codec_resume(struct hda_codec *codec) 3160 { 3161 atomic_inc(&codec->core.in_pm); 3162 3163 if (codec->core.regmap) 3164 regcache_mark_dirty(codec->core.regmap); 3165 3166 codec->power_jiffies = jiffies; 3167 3168 hda_set_power_state(codec, AC_PWRST_D0); 3169 restore_shutup_pins(codec); 3170 hda_exec_init_verbs(codec); 3171 snd_hda_jack_set_dirty_all(codec); 3172 if (codec->patch_ops.resume) 3173 codec->patch_ops.resume(codec); 3174 else { 3175 if (codec->patch_ops.init) 3176 codec->patch_ops.init(codec); 3177 if (codec->core.regmap) 3178 regcache_sync(codec->core.regmap); 3179 } 3180 3181 if (codec->jackpoll_interval) 3182 hda_jackpoll_work(&codec->jackpoll_work.work); 3183 else 3184 snd_hda_jack_report_sync(codec); 3185 atomic_dec(&codec->core.in_pm); 3186 } 3187 3188 static int hda_codec_runtime_suspend(struct device *dev) 3189 { 3190 struct hda_codec *codec = dev_to_hda_codec(dev); 3191 struct hda_pcm *pcm; 3192 unsigned int state; 3193 3194 cancel_delayed_work_sync(&codec->jackpoll_work); 3195 list_for_each_entry(pcm, &codec->pcm_list_head, list) 3196 snd_pcm_suspend_all(pcm->pcm); 3197 state = hda_call_codec_suspend(codec); 3198 if (codec_has_clkstop(codec) && codec_has_epss(codec) && 3199 (state & AC_PWRST_CLK_STOP_OK)) 3200 snd_hdac_codec_link_down(&codec->core); 3201 return 0; 3202 } 3203 3204 static int hda_codec_runtime_resume(struct device *dev) 3205 { 3206 struct hda_codec *codec = dev_to_hda_codec(dev); 3207 3208 snd_hdac_codec_link_up(&codec->core); 3209 hda_call_codec_resume(codec); 3210 pm_runtime_mark_last_busy(dev); 3211 return 0; 3212 } 3213 #endif /* CONFIG_PM */ 3214 3215 /* referred in hda_bind.c */ 3216 const struct dev_pm_ops hda_codec_driver_pm = { 3217 SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend, 3218 pm_runtime_force_resume) 3219 SET_RUNTIME_PM_OPS(hda_codec_runtime_suspend, hda_codec_runtime_resume, 3220 NULL) 3221 }; 3222 3223 /* 3224 * add standard channel maps if not specified 3225 */ 3226 static int add_std_chmaps(struct hda_codec *codec) 3227 { 3228 struct hda_pcm *pcm; 3229 int str, err; 3230 3231 list_for_each_entry(pcm, &codec->pcm_list_head, list) { 3232 for (str = 0; str < 2; str++) { 3233 struct hda_pcm_stream *hinfo = &pcm->stream[str]; 3234 struct snd_pcm_chmap *chmap; 3235 const struct snd_pcm_chmap_elem *elem; 3236 3237 if (!pcm || pcm->own_chmap || 3238 !hinfo->substreams) 3239 continue; 3240 elem = hinfo->chmap ? hinfo->chmap : snd_pcm_std_chmaps; 3241 err = snd_pcm_add_chmap_ctls(pcm->pcm, str, elem, 3242 hinfo->channels_max, 3243 0, &chmap); 3244 if (err < 0) 3245 return err; 3246 chmap->channel_mask = SND_PCM_CHMAP_MASK_2468; 3247 } 3248 } 3249 return 0; 3250 } 3251 3252 /* default channel maps for 2.1 speakers; 3253 * since HD-audio supports only stereo, odd number channels are omitted 3254 */ 3255 const struct snd_pcm_chmap_elem snd_pcm_2_1_chmaps[] = { 3256 { .channels = 2, 3257 .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR } }, 3258 { .channels = 4, 3259 .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, 3260 SNDRV_CHMAP_LFE, SNDRV_CHMAP_LFE } }, 3261 { } 3262 }; 3263 EXPORT_SYMBOL_GPL(snd_pcm_2_1_chmaps); 3264 3265 int snd_hda_codec_build_controls(struct hda_codec *codec) 3266 { 3267 int err = 0; 3268 hda_exec_init_verbs(codec); 3269 /* continue to initialize... */ 3270 if (codec->patch_ops.init) 3271 err = codec->patch_ops.init(codec); 3272 if (!err && codec->patch_ops.build_controls) 3273 err = codec->patch_ops.build_controls(codec); 3274 if (err < 0) 3275 return err; 3276 3277 /* we create chmaps here instead of build_pcms */ 3278 err = add_std_chmaps(codec); 3279 if (err < 0) 3280 return err; 3281 3282 if (codec->jackpoll_interval) 3283 hda_jackpoll_work(&codec->jackpoll_work.work); 3284 else 3285 snd_hda_jack_report_sync(codec); /* call at the last init point */ 3286 sync_power_up_states(codec); 3287 return 0; 3288 } 3289 3290 /* 3291 * stream formats 3292 */ 3293 struct hda_rate_tbl { 3294 unsigned int hz; 3295 unsigned int alsa_bits; 3296 unsigned int hda_fmt; 3297 }; 3298 3299 /* rate = base * mult / div */ 3300 #define HDA_RATE(base, mult, div) \ 3301 (AC_FMT_BASE_##base##K | (((mult) - 1) << AC_FMT_MULT_SHIFT) | \ 3302 (((div) - 1) << AC_FMT_DIV_SHIFT)) 3303 3304 static struct hda_rate_tbl rate_bits[] = { 3305 /* rate in Hz, ALSA rate bitmask, HDA format value */ 3306 3307 /* autodetected value used in snd_hda_query_supported_pcm */ 3308 { 8000, SNDRV_PCM_RATE_8000, HDA_RATE(48, 1, 6) }, 3309 { 11025, SNDRV_PCM_RATE_11025, HDA_RATE(44, 1, 4) }, 3310 { 16000, SNDRV_PCM_RATE_16000, HDA_RATE(48, 1, 3) }, 3311 { 22050, SNDRV_PCM_RATE_22050, HDA_RATE(44, 1, 2) }, 3312 { 32000, SNDRV_PCM_RATE_32000, HDA_RATE(48, 2, 3) }, 3313 { 44100, SNDRV_PCM_RATE_44100, HDA_RATE(44, 1, 1) }, 3314 { 48000, SNDRV_PCM_RATE_48000, HDA_RATE(48, 1, 1) }, 3315 { 88200, SNDRV_PCM_RATE_88200, HDA_RATE(44, 2, 1) }, 3316 { 96000, SNDRV_PCM_RATE_96000, HDA_RATE(48, 2, 1) }, 3317 { 176400, SNDRV_PCM_RATE_176400, HDA_RATE(44, 4, 1) }, 3318 { 192000, SNDRV_PCM_RATE_192000, HDA_RATE(48, 4, 1) }, 3319 #define AC_PAR_PCM_RATE_BITS 11 3320 /* up to bits 10, 384kHZ isn't supported properly */ 3321 3322 /* not autodetected value */ 3323 { 9600, SNDRV_PCM_RATE_KNOT, HDA_RATE(48, 1, 5) }, 3324 3325 { 0 } /* terminator */ 3326 }; 3327 3328 /** 3329 * snd_hda_calc_stream_format - calculate format bitset 3330 * @codec: HD-audio codec 3331 * @rate: the sample rate 3332 * @channels: the number of channels 3333 * @format: the PCM format (SNDRV_PCM_FORMAT_XXX) 3334 * @maxbps: the max. bps 3335 * @spdif_ctls: HD-audio SPDIF status bits (0 if irrelevant) 3336 * 3337 * Calculate the format bitset from the given rate, channels and th PCM format. 3338 * 3339 * Return zero if invalid. 3340 */ 3341 unsigned int snd_hda_calc_stream_format(struct hda_codec *codec, 3342 unsigned int rate, 3343 unsigned int channels, 3344 unsigned int format, 3345 unsigned int maxbps, 3346 unsigned short spdif_ctls) 3347 { 3348 int i; 3349 unsigned int val = 0; 3350 3351 for (i = 0; rate_bits[i].hz; i++) 3352 if (rate_bits[i].hz == rate) { 3353 val = rate_bits[i].hda_fmt; 3354 break; 3355 } 3356 if (!rate_bits[i].hz) { 3357 codec_dbg(codec, "invalid rate %d\n", rate); 3358 return 0; 3359 } 3360 3361 if (channels == 0 || channels > 8) { 3362 codec_dbg(codec, "invalid channels %d\n", channels); 3363 return 0; 3364 } 3365 val |= channels - 1; 3366 3367 switch (snd_pcm_format_width(format)) { 3368 case 8: 3369 val |= AC_FMT_BITS_8; 3370 break; 3371 case 16: 3372 val |= AC_FMT_BITS_16; 3373 break; 3374 case 20: 3375 case 24: 3376 case 32: 3377 if (maxbps >= 32 || format == SNDRV_PCM_FORMAT_FLOAT_LE) 3378 val |= AC_FMT_BITS_32; 3379 else if (maxbps >= 24) 3380 val |= AC_FMT_BITS_24; 3381 else 3382 val |= AC_FMT_BITS_20; 3383 break; 3384 default: 3385 codec_dbg(codec, "invalid format width %d\n", 3386 snd_pcm_format_width(format)); 3387 return 0; 3388 } 3389 3390 if (spdif_ctls & AC_DIG1_NONAUDIO) 3391 val |= AC_FMT_TYPE_NON_PCM; 3392 3393 return val; 3394 } 3395 EXPORT_SYMBOL_GPL(snd_hda_calc_stream_format); 3396 3397 static unsigned int query_pcm_param(struct hda_codec *codec, hda_nid_t nid) 3398 { 3399 unsigned int val = 0; 3400 if (nid != codec->core.afg && 3401 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD)) 3402 val = snd_hda_param_read(codec, nid, AC_PAR_PCM); 3403 if (!val || val == -1) 3404 val = snd_hda_param_read(codec, codec->core.afg, AC_PAR_PCM); 3405 if (!val || val == -1) 3406 return 0; 3407 return val; 3408 } 3409 3410 static unsigned int query_stream_param(struct hda_codec *codec, hda_nid_t nid) 3411 { 3412 unsigned int streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM); 3413 if (!streams || streams == -1) 3414 streams = snd_hda_param_read(codec, codec->core.afg, AC_PAR_STREAM); 3415 if (!streams || streams == -1) 3416 return 0; 3417 return streams; 3418 } 3419 3420 /** 3421 * snd_hda_query_supported_pcm - query the supported PCM rates and formats 3422 * @codec: the HDA codec 3423 * @nid: NID to query 3424 * @ratesp: the pointer to store the detected rate bitflags 3425 * @formatsp: the pointer to store the detected formats 3426 * @bpsp: the pointer to store the detected format widths 3427 * 3428 * Queries the supported PCM rates and formats. The NULL @ratesp, @formatsp 3429 * or @bsps argument is ignored. 3430 * 3431 * Returns 0 if successful, otherwise a negative error code. 3432 */ 3433 int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid, 3434 u32 *ratesp, u64 *formatsp, unsigned int *bpsp) 3435 { 3436 unsigned int i, val, wcaps; 3437 3438 wcaps = get_wcaps(codec, nid); 3439 val = query_pcm_param(codec, nid); 3440 3441 if (ratesp) { 3442 u32 rates = 0; 3443 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) { 3444 if (val & (1 << i)) 3445 rates |= rate_bits[i].alsa_bits; 3446 } 3447 if (rates == 0) { 3448 codec_err(codec, 3449 "rates == 0 (nid=0x%x, val=0x%x, ovrd=%i)\n", 3450 nid, val, 3451 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0); 3452 return -EIO; 3453 } 3454 *ratesp = rates; 3455 } 3456 3457 if (formatsp || bpsp) { 3458 u64 formats = 0; 3459 unsigned int streams, bps; 3460 3461 streams = query_stream_param(codec, nid); 3462 if (!streams) 3463 return -EIO; 3464 3465 bps = 0; 3466 if (streams & AC_SUPFMT_PCM) { 3467 if (val & AC_SUPPCM_BITS_8) { 3468 formats |= SNDRV_PCM_FMTBIT_U8; 3469 bps = 8; 3470 } 3471 if (val & AC_SUPPCM_BITS_16) { 3472 formats |= SNDRV_PCM_FMTBIT_S16_LE; 3473 bps = 16; 3474 } 3475 if (wcaps & AC_WCAP_DIGITAL) { 3476 if (val & AC_SUPPCM_BITS_32) 3477 formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE; 3478 if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24)) 3479 formats |= SNDRV_PCM_FMTBIT_S32_LE; 3480 if (val & AC_SUPPCM_BITS_24) 3481 bps = 24; 3482 else if (val & AC_SUPPCM_BITS_20) 3483 bps = 20; 3484 } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24| 3485 AC_SUPPCM_BITS_32)) { 3486 formats |= SNDRV_PCM_FMTBIT_S32_LE; 3487 if (val & AC_SUPPCM_BITS_32) 3488 bps = 32; 3489 else if (val & AC_SUPPCM_BITS_24) 3490 bps = 24; 3491 else if (val & AC_SUPPCM_BITS_20) 3492 bps = 20; 3493 } 3494 } 3495 #if 0 /* FIXME: CS4206 doesn't work, which is the only codec supporting float */ 3496 if (streams & AC_SUPFMT_FLOAT32) { 3497 formats |= SNDRV_PCM_FMTBIT_FLOAT_LE; 3498 if (!bps) 3499 bps = 32; 3500 } 3501 #endif 3502 if (streams == AC_SUPFMT_AC3) { 3503 /* should be exclusive */ 3504 /* temporary hack: we have still no proper support 3505 * for the direct AC3 stream... 3506 */ 3507 formats |= SNDRV_PCM_FMTBIT_U8; 3508 bps = 8; 3509 } 3510 if (formats == 0) { 3511 codec_err(codec, 3512 "formats == 0 (nid=0x%x, val=0x%x, ovrd=%i, streams=0x%x)\n", 3513 nid, val, 3514 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0, 3515 streams); 3516 return -EIO; 3517 } 3518 if (formatsp) 3519 *formatsp = formats; 3520 if (bpsp) 3521 *bpsp = bps; 3522 } 3523 3524 return 0; 3525 } 3526 EXPORT_SYMBOL_GPL(snd_hda_query_supported_pcm); 3527 3528 /** 3529 * snd_hda_is_supported_format - Check the validity of the format 3530 * @codec: HD-audio codec 3531 * @nid: NID to check 3532 * @format: the HD-audio format value to check 3533 * 3534 * Check whether the given node supports the format value. 3535 * 3536 * Returns 1 if supported, 0 if not. 3537 */ 3538 int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid, 3539 unsigned int format) 3540 { 3541 int i; 3542 unsigned int val = 0, rate, stream; 3543 3544 val = query_pcm_param(codec, nid); 3545 if (!val) 3546 return 0; 3547 3548 rate = format & 0xff00; 3549 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) 3550 if (rate_bits[i].hda_fmt == rate) { 3551 if (val & (1 << i)) 3552 break; 3553 return 0; 3554 } 3555 if (i >= AC_PAR_PCM_RATE_BITS) 3556 return 0; 3557 3558 stream = query_stream_param(codec, nid); 3559 if (!stream) 3560 return 0; 3561 3562 if (stream & AC_SUPFMT_PCM) { 3563 switch (format & 0xf0) { 3564 case 0x00: 3565 if (!(val & AC_SUPPCM_BITS_8)) 3566 return 0; 3567 break; 3568 case 0x10: 3569 if (!(val & AC_SUPPCM_BITS_16)) 3570 return 0; 3571 break; 3572 case 0x20: 3573 if (!(val & AC_SUPPCM_BITS_20)) 3574 return 0; 3575 break; 3576 case 0x30: 3577 if (!(val & AC_SUPPCM_BITS_24)) 3578 return 0; 3579 break; 3580 case 0x40: 3581 if (!(val & AC_SUPPCM_BITS_32)) 3582 return 0; 3583 break; 3584 default: 3585 return 0; 3586 } 3587 } else { 3588 /* FIXME: check for float32 and AC3? */ 3589 } 3590 3591 return 1; 3592 } 3593 EXPORT_SYMBOL_GPL(snd_hda_is_supported_format); 3594 3595 /* 3596 * PCM stuff 3597 */ 3598 static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo, 3599 struct hda_codec *codec, 3600 struct snd_pcm_substream *substream) 3601 { 3602 return 0; 3603 } 3604 3605 static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo, 3606 struct hda_codec *codec, 3607 unsigned int stream_tag, 3608 unsigned int format, 3609 struct snd_pcm_substream *substream) 3610 { 3611 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format); 3612 return 0; 3613 } 3614 3615 static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo, 3616 struct hda_codec *codec, 3617 struct snd_pcm_substream *substream) 3618 { 3619 snd_hda_codec_cleanup_stream(codec, hinfo->nid); 3620 return 0; 3621 } 3622 3623 static int set_pcm_default_values(struct hda_codec *codec, 3624 struct hda_pcm_stream *info) 3625 { 3626 int err; 3627 3628 /* query support PCM information from the given NID */ 3629 if (info->nid && (!info->rates || !info->formats)) { 3630 err = snd_hda_query_supported_pcm(codec, info->nid, 3631 info->rates ? NULL : &info->rates, 3632 info->formats ? NULL : &info->formats, 3633 info->maxbps ? NULL : &info->maxbps); 3634 if (err < 0) 3635 return err; 3636 } 3637 if (info->ops.open == NULL) 3638 info->ops.open = hda_pcm_default_open_close; 3639 if (info->ops.close == NULL) 3640 info->ops.close = hda_pcm_default_open_close; 3641 if (info->ops.prepare == NULL) { 3642 if (snd_BUG_ON(!info->nid)) 3643 return -EINVAL; 3644 info->ops.prepare = hda_pcm_default_prepare; 3645 } 3646 if (info->ops.cleanup == NULL) { 3647 if (snd_BUG_ON(!info->nid)) 3648 return -EINVAL; 3649 info->ops.cleanup = hda_pcm_default_cleanup; 3650 } 3651 return 0; 3652 } 3653 3654 /* 3655 * codec prepare/cleanup entries 3656 */ 3657 /** 3658 * snd_hda_codec_prepare - Prepare a stream 3659 * @codec: the HDA codec 3660 * @hinfo: PCM information 3661 * @stream: stream tag to assign 3662 * @format: format id to assign 3663 * @substream: PCM substream to assign 3664 * 3665 * Calls the prepare callback set by the codec with the given arguments. 3666 * Clean up the inactive streams when successful. 3667 */ 3668 int snd_hda_codec_prepare(struct hda_codec *codec, 3669 struct hda_pcm_stream *hinfo, 3670 unsigned int stream, 3671 unsigned int format, 3672 struct snd_pcm_substream *substream) 3673 { 3674 int ret; 3675 mutex_lock(&codec->bus->prepare_mutex); 3676 if (hinfo->ops.prepare) 3677 ret = hinfo->ops.prepare(hinfo, codec, stream, format, 3678 substream); 3679 else 3680 ret = -ENODEV; 3681 if (ret >= 0) 3682 purify_inactive_streams(codec); 3683 mutex_unlock(&codec->bus->prepare_mutex); 3684 return ret; 3685 } 3686 EXPORT_SYMBOL_GPL(snd_hda_codec_prepare); 3687 3688 /** 3689 * snd_hda_codec_cleanup - Prepare a stream 3690 * @codec: the HDA codec 3691 * @hinfo: PCM information 3692 * @substream: PCM substream 3693 * 3694 * Calls the cleanup callback set by the codec with the given arguments. 3695 */ 3696 void snd_hda_codec_cleanup(struct hda_codec *codec, 3697 struct hda_pcm_stream *hinfo, 3698 struct snd_pcm_substream *substream) 3699 { 3700 mutex_lock(&codec->bus->prepare_mutex); 3701 if (hinfo->ops.cleanup) 3702 hinfo->ops.cleanup(hinfo, codec, substream); 3703 mutex_unlock(&codec->bus->prepare_mutex); 3704 } 3705 EXPORT_SYMBOL_GPL(snd_hda_codec_cleanup); 3706 3707 /* global */ 3708 const char *snd_hda_pcm_type_name[HDA_PCM_NTYPES] = { 3709 "Audio", "SPDIF", "HDMI", "Modem" 3710 }; 3711 3712 /* 3713 * get the empty PCM device number to assign 3714 */ 3715 static int get_empty_pcm_device(struct hda_bus *bus, unsigned int type) 3716 { 3717 /* audio device indices; not linear to keep compatibility */ 3718 /* assigned to static slots up to dev#10; if more needed, assign 3719 * the later slot dynamically (when CONFIG_SND_DYNAMIC_MINORS=y) 3720 */ 3721 static int audio_idx[HDA_PCM_NTYPES][5] = { 3722 [HDA_PCM_TYPE_AUDIO] = { 0, 2, 4, 5, -1 }, 3723 [HDA_PCM_TYPE_SPDIF] = { 1, -1 }, 3724 [HDA_PCM_TYPE_HDMI] = { 3, 7, 8, 9, -1 }, 3725 [HDA_PCM_TYPE_MODEM] = { 6, -1 }, 3726 }; 3727 int i; 3728 3729 if (type >= HDA_PCM_NTYPES) { 3730 dev_err(bus->card->dev, "Invalid PCM type %d\n", type); 3731 return -EINVAL; 3732 } 3733 3734 for (i = 0; audio_idx[type][i] >= 0; i++) { 3735 #ifndef CONFIG_SND_DYNAMIC_MINORS 3736 if (audio_idx[type][i] >= 8) 3737 break; 3738 #endif 3739 if (!test_and_set_bit(audio_idx[type][i], bus->pcm_dev_bits)) 3740 return audio_idx[type][i]; 3741 } 3742 3743 #ifdef CONFIG_SND_DYNAMIC_MINORS 3744 /* non-fixed slots starting from 10 */ 3745 for (i = 10; i < 32; i++) { 3746 if (!test_and_set_bit(i, bus->pcm_dev_bits)) 3747 return i; 3748 } 3749 #endif 3750 3751 dev_warn(bus->card->dev, "Too many %s devices\n", 3752 snd_hda_pcm_type_name[type]); 3753 #ifndef CONFIG_SND_DYNAMIC_MINORS 3754 dev_warn(bus->card->dev, 3755 "Consider building the kernel with CONFIG_SND_DYNAMIC_MINORS=y\n"); 3756 #endif 3757 return -EAGAIN; 3758 } 3759 3760 /* call build_pcms ops of the given codec and set up the default parameters */ 3761 int snd_hda_codec_parse_pcms(struct hda_codec *codec) 3762 { 3763 struct hda_pcm *cpcm; 3764 int err; 3765 3766 if (!list_empty(&codec->pcm_list_head)) 3767 return 0; /* already parsed */ 3768 3769 if (!codec->patch_ops.build_pcms) 3770 return 0; 3771 3772 err = codec->patch_ops.build_pcms(codec); 3773 if (err < 0) { 3774 codec_err(codec, "cannot build PCMs for #%d (error %d)\n", 3775 codec->core.addr, err); 3776 return err; 3777 } 3778 3779 list_for_each_entry(cpcm, &codec->pcm_list_head, list) { 3780 int stream; 3781 3782 for (stream = 0; stream < 2; stream++) { 3783 struct hda_pcm_stream *info = &cpcm->stream[stream]; 3784 3785 if (!info->substreams) 3786 continue; 3787 err = set_pcm_default_values(codec, info); 3788 if (err < 0) { 3789 codec_warn(codec, 3790 "fail to setup default for PCM %s\n", 3791 cpcm->name); 3792 return err; 3793 } 3794 } 3795 } 3796 3797 return 0; 3798 } 3799 3800 /* assign all PCMs of the given codec */ 3801 int snd_hda_codec_build_pcms(struct hda_codec *codec) 3802 { 3803 struct hda_bus *bus = codec->bus; 3804 struct hda_pcm *cpcm; 3805 int dev, err; 3806 3807 if (snd_BUG_ON(!bus->ops.attach_pcm)) 3808 return -EINVAL; 3809 3810 err = snd_hda_codec_parse_pcms(codec); 3811 if (err < 0) { 3812 snd_hda_codec_reset(codec); 3813 return err; 3814 } 3815 3816 /* attach a new PCM streams */ 3817 list_for_each_entry(cpcm, &codec->pcm_list_head, list) { 3818 if (cpcm->pcm) 3819 continue; /* already attached */ 3820 if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams) 3821 continue; /* no substreams assigned */ 3822 3823 dev = get_empty_pcm_device(bus, cpcm->pcm_type); 3824 if (dev < 0) 3825 continue; /* no fatal error */ 3826 cpcm->device = dev; 3827 err = bus->ops.attach_pcm(bus, codec, cpcm); 3828 if (err < 0) { 3829 codec_err(codec, 3830 "cannot attach PCM stream %d for codec #%d\n", 3831 dev, codec->core.addr); 3832 continue; /* no fatal error */ 3833 } 3834 } 3835 3836 return 0; 3837 } 3838 3839 /** 3840 * snd_hda_add_new_ctls - create controls from the array 3841 * @codec: the HDA codec 3842 * @knew: the array of struct snd_kcontrol_new 3843 * 3844 * This helper function creates and add new controls in the given array. 3845 * The array must be terminated with an empty entry as terminator. 3846 * 3847 * Returns 0 if successful, or a negative error code. 3848 */ 3849 int snd_hda_add_new_ctls(struct hda_codec *codec, 3850 const struct snd_kcontrol_new *knew) 3851 { 3852 int err; 3853 3854 for (; knew->name; knew++) { 3855 struct snd_kcontrol *kctl; 3856 int addr = 0, idx = 0; 3857 if (knew->iface == -1) /* skip this codec private value */ 3858 continue; 3859 for (;;) { 3860 kctl = snd_ctl_new1(knew, codec); 3861 if (!kctl) 3862 return -ENOMEM; 3863 if (addr > 0) 3864 kctl->id.device = addr; 3865 if (idx > 0) 3866 kctl->id.index = idx; 3867 err = snd_hda_ctl_add(codec, 0, kctl); 3868 if (!err) 3869 break; 3870 /* try first with another device index corresponding to 3871 * the codec addr; if it still fails (or it's the 3872 * primary codec), then try another control index 3873 */ 3874 if (!addr && codec->core.addr) 3875 addr = codec->core.addr; 3876 else if (!idx && !knew->index) { 3877 idx = find_empty_mixer_ctl_idx(codec, 3878 knew->name, 0); 3879 if (idx <= 0) 3880 return err; 3881 } else 3882 return err; 3883 } 3884 } 3885 return 0; 3886 } 3887 EXPORT_SYMBOL_GPL(snd_hda_add_new_ctls); 3888 3889 #ifdef CONFIG_PM 3890 static void codec_set_power_save(struct hda_codec *codec, int delay) 3891 { 3892 struct device *dev = hda_codec_dev(codec); 3893 3894 if (delay > 0) { 3895 pm_runtime_set_autosuspend_delay(dev, delay); 3896 pm_runtime_use_autosuspend(dev); 3897 pm_runtime_allow(dev); 3898 if (!pm_runtime_suspended(dev)) 3899 pm_runtime_mark_last_busy(dev); 3900 } else { 3901 pm_runtime_dont_use_autosuspend(dev); 3902 pm_runtime_forbid(dev); 3903 } 3904 } 3905 3906 /** 3907 * snd_hda_set_power_save - reprogram autosuspend for the given delay 3908 * @bus: HD-audio bus 3909 * @delay: autosuspend delay in msec, 0 = off 3910 * 3911 * Synchronize the runtime PM autosuspend state from the power_save option. 3912 */ 3913 void snd_hda_set_power_save(struct hda_bus *bus, int delay) 3914 { 3915 struct hda_codec *c; 3916 3917 list_for_each_codec(c, bus) 3918 codec_set_power_save(c, delay); 3919 } 3920 EXPORT_SYMBOL_GPL(snd_hda_set_power_save); 3921 3922 /** 3923 * snd_hda_check_amp_list_power - Check the amp list and update the power 3924 * @codec: HD-audio codec 3925 * @check: the object containing an AMP list and the status 3926 * @nid: NID to check / update 3927 * 3928 * Check whether the given NID is in the amp list. If it's in the list, 3929 * check the current AMP status, and update the the power-status according 3930 * to the mute status. 3931 * 3932 * This function is supposed to be set or called from the check_power_status 3933 * patch ops. 3934 */ 3935 int snd_hda_check_amp_list_power(struct hda_codec *codec, 3936 struct hda_loopback_check *check, 3937 hda_nid_t nid) 3938 { 3939 const struct hda_amp_list *p; 3940 int ch, v; 3941 3942 if (!check->amplist) 3943 return 0; 3944 for (p = check->amplist; p->nid; p++) { 3945 if (p->nid == nid) 3946 break; 3947 } 3948 if (!p->nid) 3949 return 0; /* nothing changed */ 3950 3951 for (p = check->amplist; p->nid; p++) { 3952 for (ch = 0; ch < 2; ch++) { 3953 v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir, 3954 p->idx); 3955 if (!(v & HDA_AMP_MUTE) && v > 0) { 3956 if (!check->power_on) { 3957 check->power_on = 1; 3958 snd_hda_power_up_pm(codec); 3959 } 3960 return 1; 3961 } 3962 } 3963 } 3964 if (check->power_on) { 3965 check->power_on = 0; 3966 snd_hda_power_down_pm(codec); 3967 } 3968 return 0; 3969 } 3970 EXPORT_SYMBOL_GPL(snd_hda_check_amp_list_power); 3971 #endif 3972 3973 /* 3974 * input MUX helper 3975 */ 3976 3977 /** 3978 * snd_hda_input_mux_info_info - Info callback helper for the input-mux enum 3979 * @imux: imux helper object 3980 * @uinfo: pointer to get/store the data 3981 */ 3982 int snd_hda_input_mux_info(const struct hda_input_mux *imux, 3983 struct snd_ctl_elem_info *uinfo) 3984 { 3985 unsigned int index; 3986 3987 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 3988 uinfo->count = 1; 3989 uinfo->value.enumerated.items = imux->num_items; 3990 if (!imux->num_items) 3991 return 0; 3992 index = uinfo->value.enumerated.item; 3993 if (index >= imux->num_items) 3994 index = imux->num_items - 1; 3995 strcpy(uinfo->value.enumerated.name, imux->items[index].label); 3996 return 0; 3997 } 3998 EXPORT_SYMBOL_GPL(snd_hda_input_mux_info); 3999 4000 /** 4001 * snd_hda_input_mux_info_put - Put callback helper for the input-mux enum 4002 * @codec: the HDA codec 4003 * @imux: imux helper object 4004 * @ucontrol: pointer to get/store the data 4005 * @nid: input mux NID 4006 * @cur_val: pointer to get/store the current imux value 4007 */ 4008 int snd_hda_input_mux_put(struct hda_codec *codec, 4009 const struct hda_input_mux *imux, 4010 struct snd_ctl_elem_value *ucontrol, 4011 hda_nid_t nid, 4012 unsigned int *cur_val) 4013 { 4014 unsigned int idx; 4015 4016 if (!imux->num_items) 4017 return 0; 4018 idx = ucontrol->value.enumerated.item[0]; 4019 if (idx >= imux->num_items) 4020 idx = imux->num_items - 1; 4021 if (*cur_val == idx) 4022 return 0; 4023 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, 4024 imux->items[idx].index); 4025 *cur_val = idx; 4026 return 1; 4027 } 4028 EXPORT_SYMBOL_GPL(snd_hda_input_mux_put); 4029 4030 4031 /** 4032 * snd_hda_enum_helper_info - Helper for simple enum ctls 4033 * @kcontrol: ctl element 4034 * @uinfo: pointer to get/store the data 4035 * @num_items: number of enum items 4036 * @texts: enum item string array 4037 * 4038 * process kcontrol info callback of a simple string enum array 4039 * when @num_items is 0 or @texts is NULL, assume a boolean enum array 4040 */ 4041 int snd_hda_enum_helper_info(struct snd_kcontrol *kcontrol, 4042 struct snd_ctl_elem_info *uinfo, 4043 int num_items, const char * const *texts) 4044 { 4045 static const char * const texts_default[] = { 4046 "Disabled", "Enabled" 4047 }; 4048 4049 if (!texts || !num_items) { 4050 num_items = 2; 4051 texts = texts_default; 4052 } 4053 4054 return snd_ctl_enum_info(uinfo, 1, num_items, texts); 4055 } 4056 EXPORT_SYMBOL_GPL(snd_hda_enum_helper_info); 4057 4058 /* 4059 * Multi-channel / digital-out PCM helper functions 4060 */ 4061 4062 /* setup SPDIF output stream */ 4063 static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid, 4064 unsigned int stream_tag, unsigned int format) 4065 { 4066 struct hda_spdif_out *spdif; 4067 unsigned int curr_fmt; 4068 bool reset; 4069 4070 spdif = snd_hda_spdif_out_of_nid(codec, nid); 4071 curr_fmt = snd_hda_codec_read(codec, nid, 0, 4072 AC_VERB_GET_STREAM_FORMAT, 0); 4073 reset = codec->spdif_status_reset && 4074 (spdif->ctls & AC_DIG1_ENABLE) && 4075 curr_fmt != format; 4076 4077 /* turn off SPDIF if needed; otherwise the IEC958 bits won't be 4078 updated */ 4079 if (reset) 4080 set_dig_out_convert(codec, nid, 4081 spdif->ctls & ~AC_DIG1_ENABLE & 0xff, 4082 -1); 4083 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format); 4084 if (codec->slave_dig_outs) { 4085 const hda_nid_t *d; 4086 for (d = codec->slave_dig_outs; *d; d++) 4087 snd_hda_codec_setup_stream(codec, *d, stream_tag, 0, 4088 format); 4089 } 4090 /* turn on again (if needed) */ 4091 if (reset) 4092 set_dig_out_convert(codec, nid, 4093 spdif->ctls & 0xff, -1); 4094 } 4095 4096 static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid) 4097 { 4098 snd_hda_codec_cleanup_stream(codec, nid); 4099 if (codec->slave_dig_outs) { 4100 const hda_nid_t *d; 4101 for (d = codec->slave_dig_outs; *d; d++) 4102 snd_hda_codec_cleanup_stream(codec, *d); 4103 } 4104 } 4105 4106 /** 4107 * snd_hda_multi_out_dig_open - open the digital out in the exclusive mode 4108 * @codec: the HDA codec 4109 * @mout: hda_multi_out object 4110 */ 4111 int snd_hda_multi_out_dig_open(struct hda_codec *codec, 4112 struct hda_multi_out *mout) 4113 { 4114 mutex_lock(&codec->spdif_mutex); 4115 if (mout->dig_out_used == HDA_DIG_ANALOG_DUP) 4116 /* already opened as analog dup; reset it once */ 4117 cleanup_dig_out_stream(codec, mout->dig_out_nid); 4118 mout->dig_out_used = HDA_DIG_EXCLUSIVE; 4119 mutex_unlock(&codec->spdif_mutex); 4120 return 0; 4121 } 4122 EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_open); 4123 4124 /** 4125 * snd_hda_multi_out_dig_prepare - prepare the digital out stream 4126 * @codec: the HDA codec 4127 * @mout: hda_multi_out object 4128 * @stream_tag: stream tag to assign 4129 * @format: format id to assign 4130 * @substream: PCM substream to assign 4131 */ 4132 int snd_hda_multi_out_dig_prepare(struct hda_codec *codec, 4133 struct hda_multi_out *mout, 4134 unsigned int stream_tag, 4135 unsigned int format, 4136 struct snd_pcm_substream *substream) 4137 { 4138 mutex_lock(&codec->spdif_mutex); 4139 setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format); 4140 mutex_unlock(&codec->spdif_mutex); 4141 return 0; 4142 } 4143 EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_prepare); 4144 4145 /** 4146 * snd_hda_multi_out_dig_cleanup - clean-up the digital out stream 4147 * @codec: the HDA codec 4148 * @mout: hda_multi_out object 4149 */ 4150 int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec, 4151 struct hda_multi_out *mout) 4152 { 4153 mutex_lock(&codec->spdif_mutex); 4154 cleanup_dig_out_stream(codec, mout->dig_out_nid); 4155 mutex_unlock(&codec->spdif_mutex); 4156 return 0; 4157 } 4158 EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_cleanup); 4159 4160 /** 4161 * snd_hda_multi_out_dig_close - release the digital out stream 4162 * @codec: the HDA codec 4163 * @mout: hda_multi_out object 4164 */ 4165 int snd_hda_multi_out_dig_close(struct hda_codec *codec, 4166 struct hda_multi_out *mout) 4167 { 4168 mutex_lock(&codec->spdif_mutex); 4169 mout->dig_out_used = 0; 4170 mutex_unlock(&codec->spdif_mutex); 4171 return 0; 4172 } 4173 EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_close); 4174 4175 /** 4176 * snd_hda_multi_out_analog_open - open analog outputs 4177 * @codec: the HDA codec 4178 * @mout: hda_multi_out object 4179 * @substream: PCM substream to assign 4180 * @hinfo: PCM information to assign 4181 * 4182 * Open analog outputs and set up the hw-constraints. 4183 * If the digital outputs can be opened as slave, open the digital 4184 * outputs, too. 4185 */ 4186 int snd_hda_multi_out_analog_open(struct hda_codec *codec, 4187 struct hda_multi_out *mout, 4188 struct snd_pcm_substream *substream, 4189 struct hda_pcm_stream *hinfo) 4190 { 4191 struct snd_pcm_runtime *runtime = substream->runtime; 4192 runtime->hw.channels_max = mout->max_channels; 4193 if (mout->dig_out_nid) { 4194 if (!mout->analog_rates) { 4195 mout->analog_rates = hinfo->rates; 4196 mout->analog_formats = hinfo->formats; 4197 mout->analog_maxbps = hinfo->maxbps; 4198 } else { 4199 runtime->hw.rates = mout->analog_rates; 4200 runtime->hw.formats = mout->analog_formats; 4201 hinfo->maxbps = mout->analog_maxbps; 4202 } 4203 if (!mout->spdif_rates) { 4204 snd_hda_query_supported_pcm(codec, mout->dig_out_nid, 4205 &mout->spdif_rates, 4206 &mout->spdif_formats, 4207 &mout->spdif_maxbps); 4208 } 4209 mutex_lock(&codec->spdif_mutex); 4210 if (mout->share_spdif) { 4211 if ((runtime->hw.rates & mout->spdif_rates) && 4212 (runtime->hw.formats & mout->spdif_formats)) { 4213 runtime->hw.rates &= mout->spdif_rates; 4214 runtime->hw.formats &= mout->spdif_formats; 4215 if (mout->spdif_maxbps < hinfo->maxbps) 4216 hinfo->maxbps = mout->spdif_maxbps; 4217 } else { 4218 mout->share_spdif = 0; 4219 /* FIXME: need notify? */ 4220 } 4221 } 4222 mutex_unlock(&codec->spdif_mutex); 4223 } 4224 return snd_pcm_hw_constraint_step(substream->runtime, 0, 4225 SNDRV_PCM_HW_PARAM_CHANNELS, 2); 4226 } 4227 EXPORT_SYMBOL_GPL(snd_hda_multi_out_analog_open); 4228 4229 /** 4230 * snd_hda_multi_out_analog_prepare - Preapre the analog outputs. 4231 * @codec: the HDA codec 4232 * @mout: hda_multi_out object 4233 * @stream_tag: stream tag to assign 4234 * @format: format id to assign 4235 * @substream: PCM substream to assign 4236 * 4237 * Set up the i/o for analog out. 4238 * When the digital out is available, copy the front out to digital out, too. 4239 */ 4240 int snd_hda_multi_out_analog_prepare(struct hda_codec *codec, 4241 struct hda_multi_out *mout, 4242 unsigned int stream_tag, 4243 unsigned int format, 4244 struct snd_pcm_substream *substream) 4245 { 4246 const hda_nid_t *nids = mout->dac_nids; 4247 int chs = substream->runtime->channels; 4248 struct hda_spdif_out *spdif; 4249 int i; 4250 4251 mutex_lock(&codec->spdif_mutex); 4252 spdif = snd_hda_spdif_out_of_nid(codec, mout->dig_out_nid); 4253 if (mout->dig_out_nid && mout->share_spdif && 4254 mout->dig_out_used != HDA_DIG_EXCLUSIVE) { 4255 if (chs == 2 && 4256 snd_hda_is_supported_format(codec, mout->dig_out_nid, 4257 format) && 4258 !(spdif->status & IEC958_AES0_NONAUDIO)) { 4259 mout->dig_out_used = HDA_DIG_ANALOG_DUP; 4260 setup_dig_out_stream(codec, mout->dig_out_nid, 4261 stream_tag, format); 4262 } else { 4263 mout->dig_out_used = 0; 4264 cleanup_dig_out_stream(codec, mout->dig_out_nid); 4265 } 4266 } 4267 mutex_unlock(&codec->spdif_mutex); 4268 4269 /* front */ 4270 snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag, 4271 0, format); 4272 if (!mout->no_share_stream && 4273 mout->hp_nid && mout->hp_nid != nids[HDA_FRONT]) 4274 /* headphone out will just decode front left/right (stereo) */ 4275 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag, 4276 0, format); 4277 /* extra outputs copied from front */ 4278 for (i = 0; i < ARRAY_SIZE(mout->hp_out_nid); i++) 4279 if (!mout->no_share_stream && mout->hp_out_nid[i]) 4280 snd_hda_codec_setup_stream(codec, 4281 mout->hp_out_nid[i], 4282 stream_tag, 0, format); 4283 4284 /* surrounds */ 4285 for (i = 1; i < mout->num_dacs; i++) { 4286 if (chs >= (i + 1) * 2) /* independent out */ 4287 snd_hda_codec_setup_stream(codec, nids[i], stream_tag, 4288 i * 2, format); 4289 else if (!mout->no_share_stream) /* copy front */ 4290 snd_hda_codec_setup_stream(codec, nids[i], stream_tag, 4291 0, format); 4292 } 4293 4294 /* extra surrounds */ 4295 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++) { 4296 int ch = 0; 4297 if (!mout->extra_out_nid[i]) 4298 break; 4299 if (chs >= (i + 1) * 2) 4300 ch = i * 2; 4301 else if (!mout->no_share_stream) 4302 break; 4303 snd_hda_codec_setup_stream(codec, mout->extra_out_nid[i], 4304 stream_tag, ch, format); 4305 } 4306 4307 return 0; 4308 } 4309 EXPORT_SYMBOL_GPL(snd_hda_multi_out_analog_prepare); 4310 4311 /** 4312 * snd_hda_multi_out_analog_cleanup - clean up the setting for analog out 4313 * @codec: the HDA codec 4314 * @mout: hda_multi_out object 4315 */ 4316 int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec, 4317 struct hda_multi_out *mout) 4318 { 4319 const hda_nid_t *nids = mout->dac_nids; 4320 int i; 4321 4322 for (i = 0; i < mout->num_dacs; i++) 4323 snd_hda_codec_cleanup_stream(codec, nids[i]); 4324 if (mout->hp_nid) 4325 snd_hda_codec_cleanup_stream(codec, mout->hp_nid); 4326 for (i = 0; i < ARRAY_SIZE(mout->hp_out_nid); i++) 4327 if (mout->hp_out_nid[i]) 4328 snd_hda_codec_cleanup_stream(codec, 4329 mout->hp_out_nid[i]); 4330 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++) 4331 if (mout->extra_out_nid[i]) 4332 snd_hda_codec_cleanup_stream(codec, 4333 mout->extra_out_nid[i]); 4334 mutex_lock(&codec->spdif_mutex); 4335 if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) { 4336 cleanup_dig_out_stream(codec, mout->dig_out_nid); 4337 mout->dig_out_used = 0; 4338 } 4339 mutex_unlock(&codec->spdif_mutex); 4340 return 0; 4341 } 4342 EXPORT_SYMBOL_GPL(snd_hda_multi_out_analog_cleanup); 4343 4344 /** 4345 * snd_hda_get_default_vref - Get the default (mic) VREF pin bits 4346 * @codec: the HDA codec 4347 * @pin: referred pin NID 4348 * 4349 * Guess the suitable VREF pin bits to be set as the pin-control value. 4350 * Note: the function doesn't set the AC_PINCTL_IN_EN bit. 4351 */ 4352 unsigned int snd_hda_get_default_vref(struct hda_codec *codec, hda_nid_t pin) 4353 { 4354 unsigned int pincap; 4355 unsigned int oldval; 4356 oldval = snd_hda_codec_read(codec, pin, 0, 4357 AC_VERB_GET_PIN_WIDGET_CONTROL, 0); 4358 pincap = snd_hda_query_pin_caps(codec, pin); 4359 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT; 4360 /* Exception: if the default pin setup is vref50, we give it priority */ 4361 if ((pincap & AC_PINCAP_VREF_80) && oldval != PIN_VREF50) 4362 return AC_PINCTL_VREF_80; 4363 else if (pincap & AC_PINCAP_VREF_50) 4364 return AC_PINCTL_VREF_50; 4365 else if (pincap & AC_PINCAP_VREF_100) 4366 return AC_PINCTL_VREF_100; 4367 else if (pincap & AC_PINCAP_VREF_GRD) 4368 return AC_PINCTL_VREF_GRD; 4369 return AC_PINCTL_VREF_HIZ; 4370 } 4371 EXPORT_SYMBOL_GPL(snd_hda_get_default_vref); 4372 4373 /** 4374 * snd_hda_correct_pin_ctl - correct the pin ctl value for matching with the pin cap 4375 * @codec: the HDA codec 4376 * @pin: referred pin NID 4377 * @val: pin ctl value to audit 4378 */ 4379 unsigned int snd_hda_correct_pin_ctl(struct hda_codec *codec, 4380 hda_nid_t pin, unsigned int val) 4381 { 4382 static unsigned int cap_lists[][2] = { 4383 { AC_PINCTL_VREF_100, AC_PINCAP_VREF_100 }, 4384 { AC_PINCTL_VREF_80, AC_PINCAP_VREF_80 }, 4385 { AC_PINCTL_VREF_50, AC_PINCAP_VREF_50 }, 4386 { AC_PINCTL_VREF_GRD, AC_PINCAP_VREF_GRD }, 4387 }; 4388 unsigned int cap; 4389 4390 if (!val) 4391 return 0; 4392 cap = snd_hda_query_pin_caps(codec, pin); 4393 if (!cap) 4394 return val; /* don't know what to do... */ 4395 4396 if (val & AC_PINCTL_OUT_EN) { 4397 if (!(cap & AC_PINCAP_OUT)) 4398 val &= ~(AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN); 4399 else if ((val & AC_PINCTL_HP_EN) && !(cap & AC_PINCAP_HP_DRV)) 4400 val &= ~AC_PINCTL_HP_EN; 4401 } 4402 4403 if (val & AC_PINCTL_IN_EN) { 4404 if (!(cap & AC_PINCAP_IN)) 4405 val &= ~(AC_PINCTL_IN_EN | AC_PINCTL_VREFEN); 4406 else { 4407 unsigned int vcap, vref; 4408 int i; 4409 vcap = (cap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT; 4410 vref = val & AC_PINCTL_VREFEN; 4411 for (i = 0; i < ARRAY_SIZE(cap_lists); i++) { 4412 if (vref == cap_lists[i][0] && 4413 !(vcap & cap_lists[i][1])) { 4414 if (i == ARRAY_SIZE(cap_lists) - 1) 4415 vref = AC_PINCTL_VREF_HIZ; 4416 else 4417 vref = cap_lists[i + 1][0]; 4418 } 4419 } 4420 val &= ~AC_PINCTL_VREFEN; 4421 val |= vref; 4422 } 4423 } 4424 4425 return val; 4426 } 4427 EXPORT_SYMBOL_GPL(snd_hda_correct_pin_ctl); 4428 4429 /** 4430 * _snd_hda_pin_ctl - Helper to set pin ctl value 4431 * @codec: the HDA codec 4432 * @pin: referred pin NID 4433 * @val: pin control value to set 4434 * @cached: access over codec pinctl cache or direct write 4435 * 4436 * This function is a helper to set a pin ctl value more safely. 4437 * It corrects the pin ctl value via snd_hda_correct_pin_ctl(), stores the 4438 * value in pin target array via snd_hda_codec_set_pin_target(), then 4439 * actually writes the value via either snd_hda_codec_update_cache() or 4440 * snd_hda_codec_write() depending on @cached flag. 4441 */ 4442 int _snd_hda_set_pin_ctl(struct hda_codec *codec, hda_nid_t pin, 4443 unsigned int val, bool cached) 4444 { 4445 val = snd_hda_correct_pin_ctl(codec, pin, val); 4446 snd_hda_codec_set_pin_target(codec, pin, val); 4447 if (cached) 4448 return snd_hda_codec_update_cache(codec, pin, 0, 4449 AC_VERB_SET_PIN_WIDGET_CONTROL, val); 4450 else 4451 return snd_hda_codec_write(codec, pin, 0, 4452 AC_VERB_SET_PIN_WIDGET_CONTROL, val); 4453 } 4454 EXPORT_SYMBOL_GPL(_snd_hda_set_pin_ctl); 4455 4456 /** 4457 * snd_hda_add_imux_item - Add an item to input_mux 4458 * @codec: the HDA codec 4459 * @imux: imux helper object 4460 * @label: the name of imux item to assign 4461 * @index: index number of imux item to assign 4462 * @type_idx: pointer to store the resultant label index 4463 * 4464 * When the same label is used already in the existing items, the number 4465 * suffix is appended to the label. This label index number is stored 4466 * to type_idx when non-NULL pointer is given. 4467 */ 4468 int snd_hda_add_imux_item(struct hda_codec *codec, 4469 struct hda_input_mux *imux, const char *label, 4470 int index, int *type_idx) 4471 { 4472 int i, label_idx = 0; 4473 if (imux->num_items >= HDA_MAX_NUM_INPUTS) { 4474 codec_err(codec, "hda_codec: Too many imux items!\n"); 4475 return -EINVAL; 4476 } 4477 for (i = 0; i < imux->num_items; i++) { 4478 if (!strncmp(label, imux->items[i].label, strlen(label))) 4479 label_idx++; 4480 } 4481 if (type_idx) 4482 *type_idx = label_idx; 4483 if (label_idx > 0) 4484 snprintf(imux->items[imux->num_items].label, 4485 sizeof(imux->items[imux->num_items].label), 4486 "%s %d", label, label_idx); 4487 else 4488 strlcpy(imux->items[imux->num_items].label, label, 4489 sizeof(imux->items[imux->num_items].label)); 4490 imux->items[imux->num_items].index = index; 4491 imux->num_items++; 4492 return 0; 4493 } 4494 EXPORT_SYMBOL_GPL(snd_hda_add_imux_item); 4495 4496 /** 4497 * snd_hda_bus_reset - Reset the bus 4498 * @bus: HD-audio bus 4499 */ 4500 void snd_hda_bus_reset(struct hda_bus *bus) 4501 { 4502 struct hda_codec *codec; 4503 4504 list_for_each_codec(codec, bus) { 4505 /* FIXME: maybe a better way needed for forced reset */ 4506 cancel_delayed_work_sync(&codec->jackpoll_work); 4507 #ifdef CONFIG_PM 4508 if (hda_codec_is_power_on(codec)) { 4509 hda_call_codec_suspend(codec); 4510 hda_call_codec_resume(codec); 4511 } 4512 #endif 4513 } 4514 } 4515 EXPORT_SYMBOL_GPL(snd_hda_bus_reset); 4516 4517 /** 4518 * snd_print_pcm_bits - Print the supported PCM fmt bits to the string buffer 4519 * @pcm: PCM caps bits 4520 * @buf: the string buffer to write 4521 * @buflen: the max buffer length 4522 * 4523 * used by hda_proc.c and hda_eld.c 4524 */ 4525 void snd_print_pcm_bits(int pcm, char *buf, int buflen) 4526 { 4527 static unsigned int bits[] = { 8, 16, 20, 24, 32 }; 4528 int i, j; 4529 4530 for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++) 4531 if (pcm & (AC_SUPPCM_BITS_8 << i)) 4532 j += snprintf(buf + j, buflen - j, " %d", bits[i]); 4533 4534 buf[j] = '\0'; /* necessary when j == 0 */ 4535 } 4536 EXPORT_SYMBOL_GPL(snd_print_pcm_bits); 4537 4538 MODULE_DESCRIPTION("HDA codec core"); 4539 MODULE_LICENSE("GPL"); 4540