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