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