root/sound/pci/hda/hda_codec.c

DEFINITIONS

1. codec_exec_verb
2. snd_hda_sequence_write
3. lookup_conn_list
4. add_conn_list
5. remove_conn_list
6. read_and_add_raw_conns
7. snd_hda_get_conn_list
8. snd_hda_get_connections
9. snd_hda_override_conn_list
10. snd_hda_get_conn_index
11. snd_hda_get_num_devices
12. snd_hda_get_devices
13. snd_hda_get_dev_select
14. snd_hda_set_dev_select
15. read_widget_caps
16. read_pin_defaults
17. look_up_pincfg
18. snd_hda_add_pincfg
19. snd_hda_codec_set_pincfg
20. snd_hda_codec_get_pincfg
21. snd_hda_codec_set_pin_target
22. snd_hda_codec_get_pin_target
23. snd_hda_shutup_pins
24. restore_shutup_pins
25. hda_jackpoll_work
26. free_init_pincfgs
27. get_hda_cvt_setup
28. release_pcm
29. snd_hda_codec_pcm_put
30. snd_hda_codec_pcm_new
31. codec_release_pcms
32. snd_hda_codec_cleanup_for_unbind
33. codec_display_power
34. snd_hda_codec_register
35. snd_hda_codec_dev_register
36. snd_hda_codec_dev_free
37. snd_hda_codec_dev_release
38. snd_hda_codec_device_init
39. snd_hda_codec_new
40. snd_hda_codec_device_new
41. snd_hda_codec_update_widgets
42. update_pcm_stream_id
43. update_pcm_format
44. snd_hda_codec_setup_stream
45. __snd_hda_codec_cleanup_stream
46. really_cleanup_stream
47. purify_inactive_streams
48. hda_cleanup_all_streams
49. query_amp_caps
50. snd_hda_check_amp_caps
51. snd_hda_override_amp_caps
52. encode_amp
53. snd_hda_codec_amp_update
54. snd_hda_codec_amp_stereo
55. snd_hda_codec_amp_init
56. snd_hda_codec_amp_init_stereo
57. get_amp_max_value
58. snd_hda_mixer_amp_volume_info
59. read_amp_value
60. update_amp_value
61. snd_hda_mixer_amp_volume_get
62. snd_hda_mixer_amp_volume_put
63. get_ctl_amp_tlv
64. snd_hda_mixer_amp_tlv
65. snd_hda_set_vmaster_tlv
66. find_mixer_ctl
67. snd_hda_find_mixer_ctl
68. find_empty_mixer_ctl_idx
69. snd_hda_ctl_add
70. snd_hda_add_nid
71. snd_hda_ctls_clear
72. snd_hda_lock_devices
73. snd_hda_unlock_devices
74. snd_hda_codec_reset
75. map_slaves
76. check_slave_present
77. put_kctl_with_value
78. init_slave_0dB
79. init_slave_unmute
80. add_slave
81. __snd_hda_add_vmaster
82. vmaster_mute_mode_info
83. vmaster_mute_mode_get
84. vmaster_mute_mode_put
85. vmaster_hook
86. snd_hda_add_vmaster_hook
87. snd_hda_sync_vmaster_hook
88. snd_hda_mixer_amp_switch_info
89. snd_hda_mixer_amp_switch_get
90. snd_hda_mixer_amp_switch_put
91. snd_hda_spdif_mask_info
92. snd_hda_spdif_cmask_get
93. snd_hda_spdif_pmask_get
94. snd_hda_spdif_default_get
95. convert_from_spdif_status
96. convert_to_spdif_status
97. set_dig_out
98. set_dig_out_convert
99. snd_hda_spdif_default_put
100. snd_hda_spdif_out_switch_get
101. set_spdif_ctls
102. snd_hda_spdif_out_switch_put
103. snd_hda_create_dig_out_ctls
104. snd_hda_spdif_out_of_nid
105. snd_hda_spdif_ctls_unassign
106. snd_hda_spdif_ctls_assign
107. spdif_share_sw_get
108. spdif_share_sw_put
109. snd_hda_create_spdif_share_sw
110. snd_hda_spdif_in_switch_get
111. snd_hda_spdif_in_switch_put
112. snd_hda_spdif_in_status_get
113. snd_hda_create_spdif_in_ctls
114. snd_hda_codec_set_power_to_all
115. snd_hda_codec_eapd_power_filter
116. hda_set_power_state
117. sync_power_up_states
118. hda_exec_init_verbs
119. hda_exec_init_verbs
120. update_power_acct
121. snd_hda_update_power_acct
122. hda_call_codec_suspend
123. hda_call_codec_resume
124. hda_codec_runtime_suspend
125. hda_codec_runtime_resume
126. hda_codec_force_resume
127. hda_codec_pm_suspend
128. hda_codec_pm_resume
129. hda_codec_pm_freeze
130. hda_codec_pm_thaw
131. hda_codec_pm_restore
132. add_std_chmaps
133. snd_hda_codec_build_controls
134. hda_pcm_default_open_close
135. hda_pcm_default_prepare
136. hda_pcm_default_cleanup
137. set_pcm_default_values
138. snd_hda_codec_prepare
139. snd_hda_codec_cleanup
140. get_empty_pcm_device
141. snd_hda_codec_parse_pcms
142. snd_hda_codec_build_pcms
143. snd_hda_add_new_ctls
144. codec_set_power_save
145. snd_hda_set_power_save
146. snd_hda_check_amp_list_power
147. snd_hda_input_mux_info
148. snd_hda_input_mux_put
149. snd_hda_enum_helper_info
150. setup_dig_out_stream
151. cleanup_dig_out_stream
152. snd_hda_multi_out_dig_open
153. snd_hda_multi_out_dig_prepare
154. snd_hda_multi_out_dig_cleanup
155. snd_hda_multi_out_dig_close
156. snd_hda_multi_out_analog_open
157. snd_hda_multi_out_analog_prepare
158. snd_hda_multi_out_analog_cleanup
159. snd_hda_get_default_vref
160. snd_hda_correct_pin_ctl
161. _snd_hda_set_pin_ctl
162. snd_hda_add_imux_item
163. snd_hda_bus_reset_codecs
164. snd_print_pcm_bits

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