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