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