hda_local.h 22 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674
  1. /*
  2. * Universal Interface for Intel High Definition Audio Codec
  3. *
  4. * Local helper functions
  5. *
  6. * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de>
  7. *
  8. * This program is free software; you can redistribute it and/or modify it
  9. * under the terms of the GNU General Public License as published by the Free
  10. * Software Foundation; either version 2 of the License, or (at your option)
  11. * any later version.
  12. *
  13. * This program is distributed in the hope that it will be useful, but WITHOUT
  14. * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15. * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
  16. * more details.
  17. *
  18. * You should have received a copy of the GNU General Public License along with
  19. * this program; if not, write to the Free Software Foundation, Inc., 59
  20. * Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  21. */
  22. #ifndef __SOUND_HDA_LOCAL_H
  23. #define __SOUND_HDA_LOCAL_H
  24. /* We abuse kcontrol_new.subdev field to pass the NID corresponding to
  25. * the given new control. If id.subdev has a bit flag HDA_SUBDEV_NID_FLAG,
  26. * snd_hda_ctl_add() takes the lower-bit subdev value as a valid NID.
  27. *
  28. * Note that the subdevice field is cleared again before the real registration
  29. * in snd_hda_ctl_add(), so that this value won't appear in the outside.
  30. */
  31. #define HDA_SUBDEV_NID_FLAG (1U << 31)
  32. #define HDA_SUBDEV_AMP_FLAG (1U << 30)
  33. /*
  34. * for mixer controls
  35. */
  36. #define HDA_COMPOSE_AMP_VAL_OFS(nid,chs,idx,dir,ofs) \
  37. ((nid) | ((chs)<<16) | ((dir)<<18) | ((idx)<<19) | ((ofs)<<23))
  38. #define HDA_AMP_VAL_MIN_MUTE (1<<29)
  39. #define HDA_COMPOSE_AMP_VAL(nid,chs,idx,dir) \
  40. HDA_COMPOSE_AMP_VAL_OFS(nid, chs, idx, dir, 0)
  41. /* mono volume with index (index=0,1,...) (channel=1,2) */
  42. #define HDA_CODEC_VOLUME_MONO_IDX(xname, xcidx, nid, channel, xindex, dir, flags) \
  43. { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xcidx, \
  44. .subdevice = HDA_SUBDEV_AMP_FLAG, \
  45. .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | \
  46. SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
  47. SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK, \
  48. .info = snd_hda_mixer_amp_volume_info, \
  49. .get = snd_hda_mixer_amp_volume_get, \
  50. .put = snd_hda_mixer_amp_volume_put, \
  51. .tlv = { .c = snd_hda_mixer_amp_tlv }, \
  52. .private_value = HDA_COMPOSE_AMP_VAL(nid, channel, xindex, dir) | flags }
  53. /* stereo volume with index */
  54. #define HDA_CODEC_VOLUME_IDX(xname, xcidx, nid, xindex, direction) \
  55. HDA_CODEC_VOLUME_MONO_IDX(xname, xcidx, nid, 3, xindex, direction, 0)
  56. /* mono volume */
  57. #define HDA_CODEC_VOLUME_MONO(xname, nid, channel, xindex, direction) \
  58. HDA_CODEC_VOLUME_MONO_IDX(xname, 0, nid, channel, xindex, direction, 0)
  59. /* stereo volume */
  60. #define HDA_CODEC_VOLUME(xname, nid, xindex, direction) \
  61. HDA_CODEC_VOLUME_MONO(xname, nid, 3, xindex, direction)
  62. /* stereo volume with min=mute */
  63. #define HDA_CODEC_VOLUME_MIN_MUTE(xname, nid, xindex, direction) \
  64. HDA_CODEC_VOLUME_MONO_IDX(xname, 0, nid, 3, xindex, direction, \
  65. HDA_AMP_VAL_MIN_MUTE)
  66. /* mono mute switch with index (index=0,1,...) (channel=1,2) */
  67. #define HDA_CODEC_MUTE_MONO_IDX(xname, xcidx, nid, channel, xindex, direction) \
  68. { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xcidx, \
  69. .subdevice = HDA_SUBDEV_AMP_FLAG, \
  70. .info = snd_hda_mixer_amp_switch_info, \
  71. .get = snd_hda_mixer_amp_switch_get, \
  72. .put = snd_hda_mixer_amp_switch_put, \
  73. .private_value = HDA_COMPOSE_AMP_VAL(nid, channel, xindex, direction) }
  74. /* stereo mute switch with index */
  75. #define HDA_CODEC_MUTE_IDX(xname, xcidx, nid, xindex, direction) \
  76. HDA_CODEC_MUTE_MONO_IDX(xname, xcidx, nid, 3, xindex, direction)
  77. /* mono mute switch */
  78. #define HDA_CODEC_MUTE_MONO(xname, nid, channel, xindex, direction) \
  79. HDA_CODEC_MUTE_MONO_IDX(xname, 0, nid, channel, xindex, direction)
  80. /* stereo mute switch */
  81. #define HDA_CODEC_MUTE(xname, nid, xindex, direction) \
  82. HDA_CODEC_MUTE_MONO(xname, nid, 3, xindex, direction)
  83. #ifdef CONFIG_SND_HDA_INPUT_BEEP
  84. /* special beep mono mute switch with index (index=0,1,...) (channel=1,2) */
  85. #define HDA_CODEC_MUTE_BEEP_MONO_IDX(xname, xcidx, nid, channel, xindex, direction) \
  86. { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xcidx, \
  87. .subdevice = HDA_SUBDEV_AMP_FLAG, \
  88. .info = snd_hda_mixer_amp_switch_info, \
  89. .get = snd_hda_mixer_amp_switch_get_beep, \
  90. .put = snd_hda_mixer_amp_switch_put_beep, \
  91. .private_value = HDA_COMPOSE_AMP_VAL(nid, channel, xindex, direction) }
  92. #else
  93. /* no digital beep - just the standard one */
  94. #define HDA_CODEC_MUTE_BEEP_MONO_IDX(xname, xcidx, nid, ch, xidx, dir) \
  95. HDA_CODEC_MUTE_MONO_IDX(xname, xcidx, nid, ch, xidx, dir)
  96. #endif /* CONFIG_SND_HDA_INPUT_BEEP */
  97. /* special beep mono mute switch */
  98. #define HDA_CODEC_MUTE_BEEP_MONO(xname, nid, channel, xindex, direction) \
  99. HDA_CODEC_MUTE_BEEP_MONO_IDX(xname, 0, nid, channel, xindex, direction)
  100. /* special beep stereo mute switch */
  101. #define HDA_CODEC_MUTE_BEEP(xname, nid, xindex, direction) \
  102. HDA_CODEC_MUTE_BEEP_MONO(xname, nid, 3, xindex, direction)
  103. extern const char *snd_hda_pcm_type_name[];
  104. int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
  105. struct snd_ctl_elem_info *uinfo);
  106. int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
  107. struct snd_ctl_elem_value *ucontrol);
  108. int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
  109. struct snd_ctl_elem_value *ucontrol);
  110. int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
  111. unsigned int size, unsigned int __user *tlv);
  112. int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
  113. struct snd_ctl_elem_info *uinfo);
  114. int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
  115. struct snd_ctl_elem_value *ucontrol);
  116. int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
  117. struct snd_ctl_elem_value *ucontrol);
  118. #ifdef CONFIG_SND_HDA_INPUT_BEEP
  119. int snd_hda_mixer_amp_switch_get_beep(struct snd_kcontrol *kcontrol,
  120. struct snd_ctl_elem_value *ucontrol);
  121. int snd_hda_mixer_amp_switch_put_beep(struct snd_kcontrol *kcontrol,
  122. struct snd_ctl_elem_value *ucontrol);
  123. #endif
  124. /* lowlevel accessor with caching; use carefully */
  125. int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch,
  126. int direction, int index);
  127. int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
  128. int direction, int idx, int mask, int val);
  129. int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid,
  130. int dir, int idx, int mask, int val);
  131. #ifdef CONFIG_PM
  132. void snd_hda_codec_resume_amp(struct hda_codec *codec);
  133. #endif
  134. void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir,
  135. unsigned int *tlv);
  136. struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
  137. const char *name);
  138. int __snd_hda_add_vmaster(struct hda_codec *codec, char *name,
  139. unsigned int *tlv, const char * const *slaves,
  140. const char *suffix, bool init_slave_vol,
  141. struct snd_kcontrol **ctl_ret);
  142. #define snd_hda_add_vmaster(codec, name, tlv, slaves, suffix) \
  143. __snd_hda_add_vmaster(codec, name, tlv, slaves, suffix, true, NULL)
  144. int snd_hda_codec_reset(struct hda_codec *codec);
  145. enum {
  146. HDA_VMUTE_OFF,
  147. HDA_VMUTE_ON,
  148. HDA_VMUTE_FOLLOW_MASTER,
  149. };
  150. struct hda_vmaster_mute_hook {
  151. /* below two fields must be filled by the caller of
  152. * snd_hda_add_vmaster_hook() beforehand
  153. */
  154. struct snd_kcontrol *sw_kctl;
  155. void (*hook)(void *, int);
  156. /* below are initialized automatically */
  157. unsigned int mute_mode; /* HDA_VMUTE_XXX */
  158. struct hda_codec *codec;
  159. };
  160. int snd_hda_add_vmaster_hook(struct hda_codec *codec,
  161. struct hda_vmaster_mute_hook *hook,
  162. bool expose_enum_ctl);
  163. void snd_hda_sync_vmaster_hook(struct hda_vmaster_mute_hook *hook);
  164. /* amp value bits */
  165. #define HDA_AMP_MUTE 0x80
  166. #define HDA_AMP_UNMUTE 0x00
  167. #define HDA_AMP_VOLMASK 0x7f
  168. /* mono switch binding multiple inputs */
  169. #define HDA_BIND_MUTE_MONO(xname, nid, channel, indices, direction) \
  170. { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \
  171. .info = snd_hda_mixer_amp_switch_info, \
  172. .get = snd_hda_mixer_bind_switch_get, \
  173. .put = snd_hda_mixer_bind_switch_put, \
  174. .private_value = HDA_COMPOSE_AMP_VAL(nid, channel, indices, direction) }
  175. /* stereo switch binding multiple inputs */
  176. #define HDA_BIND_MUTE(xname,nid,indices,dir) \
  177. HDA_BIND_MUTE_MONO(xname,nid,3,indices,dir)
  178. int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
  179. struct snd_ctl_elem_value *ucontrol);
  180. int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
  181. struct snd_ctl_elem_value *ucontrol);
  182. /* more generic bound controls */
  183. struct hda_ctl_ops {
  184. snd_kcontrol_info_t *info;
  185. snd_kcontrol_get_t *get;
  186. snd_kcontrol_put_t *put;
  187. snd_kcontrol_tlv_rw_t *tlv;
  188. };
  189. extern struct hda_ctl_ops snd_hda_bind_vol; /* for bind-volume with TLV */
  190. extern struct hda_ctl_ops snd_hda_bind_sw; /* for bind-switch */
  191. struct hda_bind_ctls {
  192. struct hda_ctl_ops *ops;
  193. unsigned long values[];
  194. };
  195. int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
  196. struct snd_ctl_elem_info *uinfo);
  197. int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
  198. struct snd_ctl_elem_value *ucontrol);
  199. int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
  200. struct snd_ctl_elem_value *ucontrol);
  201. int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
  202. unsigned int size, unsigned int __user *tlv);
  203. #define HDA_BIND_VOL(xname, bindrec) \
  204. { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
  205. .name = xname, \
  206. .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |\
  207. SNDRV_CTL_ELEM_ACCESS_TLV_READ |\
  208. SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK,\
  209. .info = snd_hda_mixer_bind_ctls_info,\
  210. .get = snd_hda_mixer_bind_ctls_get,\
  211. .put = snd_hda_mixer_bind_ctls_put,\
  212. .tlv = { .c = snd_hda_mixer_bind_tlv },\
  213. .private_value = (long) (bindrec) }
  214. #define HDA_BIND_SW(xname, bindrec) \
  215. { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,\
  216. .name = xname, \
  217. .info = snd_hda_mixer_bind_ctls_info,\
  218. .get = snd_hda_mixer_bind_ctls_get,\
  219. .put = snd_hda_mixer_bind_ctls_put,\
  220. .private_value = (long) (bindrec) }
  221. /*
  222. * SPDIF I/O
  223. */
  224. int snd_hda_create_spdif_out_ctls(struct hda_codec *codec,
  225. hda_nid_t associated_nid,
  226. hda_nid_t cvt_nid);
  227. int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid);
  228. /*
  229. * input MUX helper
  230. */
  231. #define HDA_MAX_NUM_INPUTS 16
  232. struct hda_input_mux_item {
  233. char label[32];
  234. unsigned int index;
  235. };
  236. struct hda_input_mux {
  237. unsigned int num_items;
  238. struct hda_input_mux_item items[HDA_MAX_NUM_INPUTS];
  239. };
  240. int snd_hda_input_mux_info(const struct hda_input_mux *imux,
  241. struct snd_ctl_elem_info *uinfo);
  242. int snd_hda_input_mux_put(struct hda_codec *codec,
  243. const struct hda_input_mux *imux,
  244. struct snd_ctl_elem_value *ucontrol, hda_nid_t nid,
  245. unsigned int *cur_val);
  246. int snd_hda_add_imux_item(struct hda_input_mux *imux, const char *label,
  247. int index, int *type_index_ret);
  248. /*
  249. * Channel mode helper
  250. */
  251. struct hda_channel_mode {
  252. int channels;
  253. const struct hda_verb *sequence;
  254. };
  255. int snd_hda_ch_mode_info(struct hda_codec *codec,
  256. struct snd_ctl_elem_info *uinfo,
  257. const struct hda_channel_mode *chmode,
  258. int num_chmodes);
  259. int snd_hda_ch_mode_get(struct hda_codec *codec,
  260. struct snd_ctl_elem_value *ucontrol,
  261. const struct hda_channel_mode *chmode,
  262. int num_chmodes,
  263. int max_channels);
  264. int snd_hda_ch_mode_put(struct hda_codec *codec,
  265. struct snd_ctl_elem_value *ucontrol,
  266. const struct hda_channel_mode *chmode,
  267. int num_chmodes,
  268. int *max_channelsp);
  269. /*
  270. * Multi-channel / digital-out PCM helper
  271. */
  272. enum { HDA_FRONT, HDA_REAR, HDA_CLFE, HDA_SIDE }; /* index for dac_nidx */
  273. enum { HDA_DIG_NONE, HDA_DIG_EXCLUSIVE, HDA_DIG_ANALOG_DUP }; /* dig_out_used */
  274. #define HDA_MAX_OUTS 5
  275. struct hda_multi_out {
  276. int num_dacs; /* # of DACs, must be more than 1 */
  277. const hda_nid_t *dac_nids; /* DAC list */
  278. hda_nid_t hp_nid; /* optional DAC for HP, 0 when not exists */
  279. hda_nid_t hp_out_nid[HDA_MAX_OUTS]; /* DACs for multiple HPs */
  280. hda_nid_t extra_out_nid[HDA_MAX_OUTS]; /* other (e.g. speaker) DACs */
  281. hda_nid_t dig_out_nid; /* digital out audio widget */
  282. const hda_nid_t *slave_dig_outs;
  283. int max_channels; /* currently supported analog channels */
  284. int dig_out_used; /* current usage of digital out (HDA_DIG_XXX) */
  285. int no_share_stream; /* don't share a stream with multiple pins */
  286. int share_spdif; /* share SPDIF pin */
  287. /* PCM information for both analog and SPDIF DACs */
  288. unsigned int analog_rates;
  289. unsigned int analog_maxbps;
  290. u64 analog_formats;
  291. unsigned int spdif_rates;
  292. unsigned int spdif_maxbps;
  293. u64 spdif_formats;
  294. };
  295. int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
  296. struct hda_multi_out *mout);
  297. int snd_hda_multi_out_dig_open(struct hda_codec *codec,
  298. struct hda_multi_out *mout);
  299. int snd_hda_multi_out_dig_close(struct hda_codec *codec,
  300. struct hda_multi_out *mout);
  301. int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
  302. struct hda_multi_out *mout,
  303. unsigned int stream_tag,
  304. unsigned int format,
  305. struct snd_pcm_substream *substream);
  306. int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec,
  307. struct hda_multi_out *mout);
  308. int snd_hda_multi_out_analog_open(struct hda_codec *codec,
  309. struct hda_multi_out *mout,
  310. struct snd_pcm_substream *substream,
  311. struct hda_pcm_stream *hinfo);
  312. int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
  313. struct hda_multi_out *mout,
  314. unsigned int stream_tag,
  315. unsigned int format,
  316. struct snd_pcm_substream *substream);
  317. int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
  318. struct hda_multi_out *mout);
  319. /*
  320. * generic codec parser
  321. */
  322. #ifdef CONFIG_SND_HDA_GENERIC
  323. int snd_hda_parse_generic_codec(struct hda_codec *codec);
  324. #else
  325. static inline int snd_hda_parse_generic_codec(struct hda_codec *codec)
  326. {
  327. return -ENODEV;
  328. }
  329. #endif
  330. /*
  331. * generic proc interface
  332. */
  333. #ifdef CONFIG_PROC_FS
  334. int snd_hda_codec_proc_new(struct hda_codec *codec);
  335. #else
  336. static inline int snd_hda_codec_proc_new(struct hda_codec *codec) { return 0; }
  337. #endif
  338. #define SND_PRINT_BITS_ADVISED_BUFSIZE 16
  339. void snd_print_pcm_bits(int pcm, char *buf, int buflen);
  340. /*
  341. * Misc
  342. */
  343. int snd_hda_check_board_config(struct hda_codec *codec, int num_configs,
  344. const char * const *modelnames,
  345. const struct snd_pci_quirk *pci_list);
  346. int snd_hda_check_board_codec_sid_config(struct hda_codec *codec,
  347. int num_configs, const char * const *models,
  348. const struct snd_pci_quirk *tbl);
  349. int snd_hda_add_new_ctls(struct hda_codec *codec,
  350. const struct snd_kcontrol_new *knew);
  351. /*
  352. * unsolicited event handler
  353. */
  354. #define HDA_UNSOL_QUEUE_SIZE 64
  355. struct hda_bus_unsolicited {
  356. /* ring buffer */
  357. u32 queue[HDA_UNSOL_QUEUE_SIZE * 2];
  358. unsigned int rp, wp;
  359. /* workqueue */
  360. struct work_struct work;
  361. struct hda_bus *bus;
  362. };
  363. /* helper macros to retrieve pin default-config values */
  364. #define get_defcfg_connect(cfg) \
  365. ((cfg & AC_DEFCFG_PORT_CONN) >> AC_DEFCFG_PORT_CONN_SHIFT)
  366. #define get_defcfg_association(cfg) \
  367. ((cfg & AC_DEFCFG_DEF_ASSOC) >> AC_DEFCFG_ASSOC_SHIFT)
  368. #define get_defcfg_location(cfg) \
  369. ((cfg & AC_DEFCFG_LOCATION) >> AC_DEFCFG_LOCATION_SHIFT)
  370. #define get_defcfg_sequence(cfg) \
  371. (cfg & AC_DEFCFG_SEQUENCE)
  372. #define get_defcfg_device(cfg) \
  373. ((cfg & AC_DEFCFG_DEVICE) >> AC_DEFCFG_DEVICE_SHIFT)
  374. #define get_defcfg_misc(cfg) \
  375. ((cfg & AC_DEFCFG_MISC) >> AC_DEFCFG_MISC_SHIFT)
  376. /* amp values */
  377. #define AMP_IN_MUTE(idx) (0x7080 | ((idx)<<8))
  378. #define AMP_IN_UNMUTE(idx) (0x7000 | ((idx)<<8))
  379. #define AMP_OUT_MUTE 0xb080
  380. #define AMP_OUT_UNMUTE 0xb000
  381. #define AMP_OUT_ZERO 0xb000
  382. /* pinctl values */
  383. #define PIN_IN (AC_PINCTL_IN_EN)
  384. #define PIN_VREFHIZ (AC_PINCTL_IN_EN | AC_PINCTL_VREF_HIZ)
  385. #define PIN_VREF50 (AC_PINCTL_IN_EN | AC_PINCTL_VREF_50)
  386. #define PIN_VREFGRD (AC_PINCTL_IN_EN | AC_PINCTL_VREF_GRD)
  387. #define PIN_VREF80 (AC_PINCTL_IN_EN | AC_PINCTL_VREF_80)
  388. #define PIN_VREF100 (AC_PINCTL_IN_EN | AC_PINCTL_VREF_100)
  389. #define PIN_OUT (AC_PINCTL_OUT_EN)
  390. #define PIN_HP (AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN)
  391. #define PIN_HP_AMP (AC_PINCTL_HP_EN)
  392. unsigned int snd_hda_get_default_vref(struct hda_codec *codec, hda_nid_t pin);
  393. int _snd_hda_set_pin_ctl(struct hda_codec *codec, hda_nid_t pin,
  394. unsigned int val, bool cached);
  395. /**
  396. * _snd_hda_set_pin_ctl - Set a pin-control value safely
  397. * @codec: the codec instance
  398. * @pin: the pin NID to set the control
  399. * @val: the pin-control value (AC_PINCTL_* bits)
  400. *
  401. * This function sets the pin-control value to the given pin, but
  402. * filters out the invalid pin-control bits when the pin has no such
  403. * capabilities. For example, when PIN_HP is passed but the pin has no
  404. * HP-drive capability, the HP bit is omitted.
  405. *
  406. * The function doesn't check the input VREF capability bits, though.
  407. * Use snd_hda_get_default_vref() to guess the right value.
  408. * Also, this function is only for analog pins, not for HDMI pins.
  409. */
  410. static inline int
  411. snd_hda_set_pin_ctl(struct hda_codec *codec, hda_nid_t pin, unsigned int val)
  412. {
  413. return _snd_hda_set_pin_ctl(codec, pin, val, false);
  414. }
  415. /**
  416. * snd_hda_set_pin_ctl_cache - Set a pin-control value safely
  417. * @codec: the codec instance
  418. * @pin: the pin NID to set the control
  419. * @val: the pin-control value (AC_PINCTL_* bits)
  420. *
  421. * Just like snd_hda_set_pin_ctl() but write to cache as well.
  422. */
  423. static inline int
  424. snd_hda_set_pin_ctl_cache(struct hda_codec *codec, hda_nid_t pin,
  425. unsigned int val)
  426. {
  427. return _snd_hda_set_pin_ctl(codec, pin, val, true);
  428. }
  429. /*
  430. * get widget capabilities
  431. */
  432. static inline u32 get_wcaps(struct hda_codec *codec, hda_nid_t nid)
  433. {
  434. if (nid < codec->start_nid ||
  435. nid >= codec->start_nid + codec->num_nodes)
  436. return 0;
  437. return codec->wcaps[nid - codec->start_nid];
  438. }
  439. /* get the widget type from widget capability bits */
  440. static inline int get_wcaps_type(unsigned int wcaps)
  441. {
  442. if (!wcaps)
  443. return -1; /* invalid type */
  444. return (wcaps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
  445. }
  446. static inline unsigned int get_wcaps_channels(u32 wcaps)
  447. {
  448. unsigned int chans;
  449. chans = (wcaps & AC_WCAP_CHAN_CNT_EXT) >> 13;
  450. chans = ((chans << 1) | 1) + 1;
  451. return chans;
  452. }
  453. u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction);
  454. int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
  455. unsigned int caps);
  456. u32 snd_hda_query_pin_caps(struct hda_codec *codec, hda_nid_t nid);
  457. int snd_hda_override_pin_caps(struct hda_codec *codec, hda_nid_t nid,
  458. unsigned int caps);
  459. /* flags for hda_nid_item */
  460. #define HDA_NID_ITEM_AMP (1<<0)
  461. struct hda_nid_item {
  462. struct snd_kcontrol *kctl;
  463. unsigned int index;
  464. hda_nid_t nid;
  465. unsigned short flags;
  466. };
  467. int snd_hda_ctl_add(struct hda_codec *codec, hda_nid_t nid,
  468. struct snd_kcontrol *kctl);
  469. int snd_hda_add_nid(struct hda_codec *codec, struct snd_kcontrol *kctl,
  470. unsigned int index, hda_nid_t nid);
  471. void snd_hda_ctls_clear(struct hda_codec *codec);
  472. /*
  473. * hwdep interface
  474. */
  475. #ifdef CONFIG_SND_HDA_HWDEP
  476. int snd_hda_create_hwdep(struct hda_codec *codec);
  477. #else
  478. static inline int snd_hda_create_hwdep(struct hda_codec *codec) { return 0; }
  479. #endif
  480. #if defined(CONFIG_SND_HDA_POWER_SAVE) && defined(CONFIG_SND_HDA_HWDEP)
  481. int snd_hda_hwdep_add_power_sysfs(struct hda_codec *codec);
  482. #else
  483. static inline int snd_hda_hwdep_add_power_sysfs(struct hda_codec *codec)
  484. {
  485. return 0;
  486. }
  487. #endif
  488. #ifdef CONFIG_SND_HDA_RECONFIG
  489. int snd_hda_hwdep_add_sysfs(struct hda_codec *codec);
  490. #else
  491. static inline int snd_hda_hwdep_add_sysfs(struct hda_codec *codec)
  492. {
  493. return 0;
  494. }
  495. #endif
  496. #ifdef CONFIG_SND_HDA_RECONFIG
  497. const char *snd_hda_get_hint(struct hda_codec *codec, const char *key);
  498. int snd_hda_get_bool_hint(struct hda_codec *codec, const char *key);
  499. #else
  500. static inline
  501. const char *snd_hda_get_hint(struct hda_codec *codec, const char *key)
  502. {
  503. return NULL;
  504. }
  505. static inline
  506. int snd_hda_get_bool_hint(struct hda_codec *codec, const char *key)
  507. {
  508. return -ENOENT;
  509. }
  510. #endif
  511. /*
  512. * power-management
  513. */
  514. void snd_hda_schedule_power_save(struct hda_codec *codec);
  515. struct hda_amp_list {
  516. hda_nid_t nid;
  517. unsigned char dir;
  518. unsigned char idx;
  519. };
  520. struct hda_loopback_check {
  521. const struct hda_amp_list *amplist;
  522. int power_on;
  523. };
  524. int snd_hda_check_amp_list_power(struct hda_codec *codec,
  525. struct hda_loopback_check *check,
  526. hda_nid_t nid);
  527. /*
  528. * AMP control callbacks
  529. */
  530. /* retrieve parameters from private_value */
  531. #define get_amp_nid_(pv) ((pv) & 0xffff)
  532. #define get_amp_nid(kc) get_amp_nid_((kc)->private_value)
  533. #define get_amp_channels(kc) (((kc)->private_value >> 16) & 0x3)
  534. #define get_amp_direction_(pv) (((pv) >> 18) & 0x1)
  535. #define get_amp_direction(kc) get_amp_direction_((kc)->private_value)
  536. #define get_amp_index(kc) (((kc)->private_value >> 19) & 0xf)
  537. #define get_amp_offset(kc) (((kc)->private_value >> 23) & 0x3f)
  538. #define get_amp_min_mute(kc) (((kc)->private_value >> 29) & 0x1)
  539. /*
  540. * CEA Short Audio Descriptor data
  541. */
  542. struct cea_sad {
  543. int channels;
  544. int format; /* (format == 0) indicates invalid SAD */
  545. int rates;
  546. int sample_bits; /* for LPCM */
  547. int max_bitrate; /* for AC3...ATRAC */
  548. int profile; /* for WMAPRO */
  549. };
  550. #define ELD_FIXED_BYTES 20
  551. #define ELD_MAX_SIZE 256
  552. #define ELD_MAX_MNL 16
  553. #define ELD_MAX_SAD 16
  554. /*
  555. * ELD: EDID Like Data
  556. */
  557. struct hdmi_eld {
  558. bool monitor_present;
  559. bool eld_valid;
  560. int eld_size;
  561. int baseline_len;
  562. int eld_ver;
  563. int cea_edid_ver;
  564. char monitor_name[ELD_MAX_MNL + 1];
  565. int manufacture_id;
  566. int product_id;
  567. u64 port_id;
  568. int support_hdcp;
  569. int support_ai;
  570. int conn_type;
  571. int aud_synch_delay;
  572. int spk_alloc;
  573. int sad_count;
  574. struct cea_sad sad[ELD_MAX_SAD];
  575. /*
  576. * all fields above eld_buffer will be cleared before updating ELD
  577. */
  578. char eld_buffer[ELD_MAX_SIZE];
  579. #ifdef CONFIG_PROC_FS
  580. struct snd_info_entry *proc_entry;
  581. #endif
  582. };
  583. int snd_hdmi_get_eld_size(struct hda_codec *codec, hda_nid_t nid);
  584. int snd_hdmi_get_eld(struct hdmi_eld *, struct hda_codec *, hda_nid_t);
  585. void snd_hdmi_show_eld(struct hdmi_eld *eld);
  586. void snd_hdmi_eld_update_pcm_info(struct hdmi_eld *eld,
  587. struct hda_pcm_stream *hinfo);
  588. #ifdef CONFIG_PROC_FS
  589. int snd_hda_eld_proc_new(struct hda_codec *codec, struct hdmi_eld *eld,
  590. int index);
  591. void snd_hda_eld_proc_free(struct hda_codec *codec, struct hdmi_eld *eld);
  592. #else
  593. static inline int snd_hda_eld_proc_new(struct hda_codec *codec,
  594. struct hdmi_eld *eld,
  595. int index)
  596. {
  597. return 0;
  598. }
  599. static inline void snd_hda_eld_proc_free(struct hda_codec *codec,
  600. struct hdmi_eld *eld)
  601. {
  602. }
  603. #endif
  604. #define SND_PRINT_CHANNEL_ALLOCATION_ADVISED_BUFSIZE 80
  605. void snd_print_channel_allocation(int spk_alloc, char *buf, int buflen);
  606. #endif /* __SOUND_HDA_LOCAL_H */