| 1 | /* |
| 2 | * Universal Interface for Intel High Definition Audio Codec |
| 3 | * |
| 4 | * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de> |
| 5 | * |
| 6 | * This program is free software; you can redistribute it and/or modify it |
| 7 | * under the terms of the GNU General Public License as published by the Free |
| 8 | * Software Foundation; either version 2 of the License, or (at your option) |
| 9 | * any later version. |
| 10 | * |
| 11 | * This program is distributed in the hope that it will be useful, but WITHOUT |
| 12 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| 13 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for |
| 14 | * more details. |
| 15 | * |
| 16 | * You should have received a copy of the GNU General Public License along with |
| 17 | * this program; if not, write to the Free Software Foundation, Inc., 59 |
| 18 | * Temple Place - Suite 330, Boston, MA 02111-1307, USA. |
| 19 | */ |
| 20 | |
| 21 | #ifndef __SOUND_HDA_CODEC_H |
| 22 | #define __SOUND_HDA_CODEC_H |
| 23 | |
| 24 | #include <sound/info.h> |
| 25 | #include <sound/control.h> |
| 26 | #include <sound/pcm.h> |
| 27 | #include <sound/hwdep.h> |
| 28 | #include <sound/hda_verbs.h> |
| 29 | |
| 30 | /* |
| 31 | * generic arrays |
| 32 | */ |
| 33 | struct snd_array { |
| 34 | unsigned int used; |
| 35 | unsigned int alloced; |
| 36 | unsigned int elem_size; |
| 37 | unsigned int alloc_align; |
| 38 | void *list; |
| 39 | }; |
| 40 | |
| 41 | void *snd_array_new(struct snd_array *array); |
| 42 | void snd_array_free(struct snd_array *array); |
| 43 | static inline void snd_array_init(struct snd_array *array, unsigned int size, |
| 44 | unsigned int align) |
| 45 | { |
| 46 | array->elem_size = size; |
| 47 | array->alloc_align = align; |
| 48 | } |
| 49 | |
| 50 | static inline void *snd_array_elem(struct snd_array *array, unsigned int idx) |
| 51 | { |
| 52 | return array->list + idx * array->elem_size; |
| 53 | } |
| 54 | |
| 55 | static inline unsigned int snd_array_index(struct snd_array *array, void *ptr) |
| 56 | { |
| 57 | return (unsigned long)(ptr - array->list) / array->elem_size; |
| 58 | } |
| 59 | |
| 60 | /* |
| 61 | * Structures |
| 62 | */ |
| 63 | |
| 64 | struct hda_bus; |
| 65 | struct hda_beep; |
| 66 | struct hda_codec; |
| 67 | struct hda_pcm; |
| 68 | struct hda_pcm_stream; |
| 69 | struct hda_bus_unsolicited; |
| 70 | |
| 71 | /* NID type */ |
| 72 | typedef u16 hda_nid_t; |
| 73 | |
| 74 | /* bus operators */ |
| 75 | struct hda_bus_ops { |
| 76 | /* send a single command */ |
| 77 | int (*command)(struct hda_bus *bus, unsigned int cmd); |
| 78 | /* get a response from the last command */ |
| 79 | unsigned int (*get_response)(struct hda_bus *bus, unsigned int addr); |
| 80 | /* free the private data */ |
| 81 | void (*private_free)(struct hda_bus *); |
| 82 | /* attach a PCM stream */ |
| 83 | int (*attach_pcm)(struct hda_bus *bus, struct hda_codec *codec, |
| 84 | struct hda_pcm *pcm); |
| 85 | /* reset bus for retry verb */ |
| 86 | void (*bus_reset)(struct hda_bus *bus); |
| 87 | #ifdef CONFIG_PM |
| 88 | /* notify power-up/down from codec to controller */ |
| 89 | void (*pm_notify)(struct hda_bus *bus, bool power_up); |
| 90 | #endif |
| 91 | #ifdef CONFIG_SND_HDA_DSP_LOADER |
| 92 | /* prepare DSP transfer */ |
| 93 | int (*load_dsp_prepare)(struct hda_bus *bus, unsigned int format, |
| 94 | unsigned int byte_size, |
| 95 | struct snd_dma_buffer *bufp); |
| 96 | /* start/stop DSP transfer */ |
| 97 | void (*load_dsp_trigger)(struct hda_bus *bus, bool start); |
| 98 | /* clean up DSP transfer */ |
| 99 | void (*load_dsp_cleanup)(struct hda_bus *bus, |
| 100 | struct snd_dma_buffer *dmab); |
| 101 | #endif |
| 102 | }; |
| 103 | |
| 104 | /* template to pass to the bus constructor */ |
| 105 | struct hda_bus_template { |
| 106 | void *private_data; |
| 107 | struct pci_dev *pci; |
| 108 | const char *modelname; |
| 109 | int *power_save; |
| 110 | struct hda_bus_ops ops; |
| 111 | }; |
| 112 | |
| 113 | /* |
| 114 | * codec bus |
| 115 | * |
| 116 | * each controller needs to creata a hda_bus to assign the accessor. |
| 117 | * A hda_bus contains several codecs in the list codec_list. |
| 118 | */ |
| 119 | struct hda_bus { |
| 120 | struct snd_card *card; |
| 121 | |
| 122 | /* copied from template */ |
| 123 | void *private_data; |
| 124 | struct pci_dev *pci; |
| 125 | const char *modelname; |
| 126 | int *power_save; |
| 127 | struct hda_bus_ops ops; |
| 128 | |
| 129 | /* codec linked list */ |
| 130 | struct list_head codec_list; |
| 131 | unsigned int num_codecs; |
| 132 | /* link caddr -> codec */ |
| 133 | struct hda_codec *caddr_tbl[HDA_MAX_CODEC_ADDRESS + 1]; |
| 134 | |
| 135 | struct mutex cmd_mutex; |
| 136 | struct mutex prepare_mutex; |
| 137 | |
| 138 | /* unsolicited event queue */ |
| 139 | struct hda_bus_unsolicited *unsol; |
| 140 | char workq_name[16]; |
| 141 | struct workqueue_struct *workq; /* common workqueue for codecs */ |
| 142 | |
| 143 | /* assigned PCMs */ |
| 144 | DECLARE_BITMAP(pcm_dev_bits, SNDRV_PCM_DEVICES); |
| 145 | |
| 146 | /* misc op flags */ |
| 147 | unsigned int needs_damn_long_delay :1; |
| 148 | unsigned int allow_bus_reset:1; /* allow bus reset at fatal error */ |
| 149 | unsigned int sync_write:1; /* sync after verb write */ |
| 150 | /* status for codec/controller */ |
| 151 | unsigned int shutdown :1; /* being unloaded */ |
| 152 | unsigned int rirb_error:1; /* error in codec communication */ |
| 153 | unsigned int response_reset:1; /* controller was reset */ |
| 154 | unsigned int in_reset:1; /* during reset operation */ |
| 155 | unsigned int power_keep_link_on:1; /* don't power off HDA link */ |
| 156 | unsigned int no_response_fallback:1; /* don't fallback at RIRB error */ |
| 157 | |
| 158 | int primary_dig_out_type; /* primary digital out PCM type */ |
| 159 | }; |
| 160 | |
| 161 | /* |
| 162 | * codec preset |
| 163 | * |
| 164 | * Known codecs have the patch to build and set up the controls/PCMs |
| 165 | * better than the generic parser. |
| 166 | */ |
| 167 | struct hda_codec_preset { |
| 168 | unsigned int id; |
| 169 | unsigned int mask; |
| 170 | unsigned int subs; |
| 171 | unsigned int subs_mask; |
| 172 | unsigned int rev; |
| 173 | hda_nid_t afg, mfg; |
| 174 | const char *name; |
| 175 | int (*patch)(struct hda_codec *codec); |
| 176 | }; |
| 177 | |
| 178 | struct hda_codec_preset_list { |
| 179 | const struct hda_codec_preset *preset; |
| 180 | struct module *owner; |
| 181 | struct list_head list; |
| 182 | }; |
| 183 | |
| 184 | /* initial hook */ |
| 185 | int snd_hda_add_codec_preset(struct hda_codec_preset_list *preset); |
| 186 | int snd_hda_delete_codec_preset(struct hda_codec_preset_list *preset); |
| 187 | |
| 188 | /* ops set by the preset patch */ |
| 189 | struct hda_codec_ops { |
| 190 | int (*build_controls)(struct hda_codec *codec); |
| 191 | int (*build_pcms)(struct hda_codec *codec); |
| 192 | int (*init)(struct hda_codec *codec); |
| 193 | void (*free)(struct hda_codec *codec); |
| 194 | void (*unsol_event)(struct hda_codec *codec, unsigned int res); |
| 195 | void (*set_power_state)(struct hda_codec *codec, hda_nid_t fg, |
| 196 | unsigned int power_state); |
| 197 | #ifdef CONFIG_PM |
| 198 | int (*suspend)(struct hda_codec *codec); |
| 199 | int (*resume)(struct hda_codec *codec); |
| 200 | int (*check_power_status)(struct hda_codec *codec, hda_nid_t nid); |
| 201 | #endif |
| 202 | void (*reboot_notify)(struct hda_codec *codec); |
| 203 | }; |
| 204 | |
| 205 | /* record for amp information cache */ |
| 206 | struct hda_cache_head { |
| 207 | u32 key:31; /* hash key */ |
| 208 | u32 dirty:1; |
| 209 | u16 val; /* assigned value */ |
| 210 | u16 next; |
| 211 | }; |
| 212 | |
| 213 | struct hda_amp_info { |
| 214 | struct hda_cache_head head; |
| 215 | u32 amp_caps; /* amp capabilities */ |
| 216 | u16 vol[2]; /* current volume & mute */ |
| 217 | }; |
| 218 | |
| 219 | struct hda_cache_rec { |
| 220 | u16 hash[64]; /* hash table for index */ |
| 221 | struct snd_array buf; /* record entries */ |
| 222 | }; |
| 223 | |
| 224 | /* PCM callbacks */ |
| 225 | struct hda_pcm_ops { |
| 226 | int (*open)(struct hda_pcm_stream *info, struct hda_codec *codec, |
| 227 | struct snd_pcm_substream *substream); |
| 228 | int (*close)(struct hda_pcm_stream *info, struct hda_codec *codec, |
| 229 | struct snd_pcm_substream *substream); |
| 230 | int (*prepare)(struct hda_pcm_stream *info, struct hda_codec *codec, |
| 231 | unsigned int stream_tag, unsigned int format, |
| 232 | struct snd_pcm_substream *substream); |
| 233 | int (*cleanup)(struct hda_pcm_stream *info, struct hda_codec *codec, |
| 234 | struct snd_pcm_substream *substream); |
| 235 | unsigned int (*get_delay)(struct hda_pcm_stream *info, |
| 236 | struct hda_codec *codec, |
| 237 | struct snd_pcm_substream *substream); |
| 238 | }; |
| 239 | |
| 240 | /* PCM information for each substream */ |
| 241 | struct hda_pcm_stream { |
| 242 | unsigned int substreams; /* number of substreams, 0 = not exist*/ |
| 243 | unsigned int channels_min; /* min. number of channels */ |
| 244 | unsigned int channels_max; /* max. number of channels */ |
| 245 | hda_nid_t nid; /* default NID to query rates/formats/bps, or set up */ |
| 246 | u32 rates; /* supported rates */ |
| 247 | u64 formats; /* supported formats (SNDRV_PCM_FMTBIT_) */ |
| 248 | unsigned int maxbps; /* supported max. bit per sample */ |
| 249 | const struct snd_pcm_chmap_elem *chmap; /* chmap to override */ |
| 250 | struct hda_pcm_ops ops; |
| 251 | }; |
| 252 | |
| 253 | /* PCM types */ |
| 254 | enum { |
| 255 | HDA_PCM_TYPE_AUDIO, |
| 256 | HDA_PCM_TYPE_SPDIF, |
| 257 | HDA_PCM_TYPE_HDMI, |
| 258 | HDA_PCM_TYPE_MODEM, |
| 259 | HDA_PCM_NTYPES |
| 260 | }; |
| 261 | |
| 262 | /* for PCM creation */ |
| 263 | struct hda_pcm { |
| 264 | char *name; |
| 265 | struct hda_pcm_stream stream[2]; |
| 266 | unsigned int pcm_type; /* HDA_PCM_TYPE_XXX */ |
| 267 | int device; /* device number to assign */ |
| 268 | struct snd_pcm *pcm; /* assigned PCM instance */ |
| 269 | bool own_chmap; /* codec driver provides own channel maps */ |
| 270 | }; |
| 271 | |
| 272 | /* codec information */ |
| 273 | struct hda_codec { |
| 274 | struct device dev; |
| 275 | struct hda_bus *bus; |
| 276 | unsigned int addr; /* codec addr*/ |
| 277 | struct list_head list; /* list point */ |
| 278 | |
| 279 | hda_nid_t afg; /* AFG node id */ |
| 280 | hda_nid_t mfg; /* MFG node id */ |
| 281 | |
| 282 | /* ids */ |
| 283 | u8 afg_function_id; |
| 284 | u8 mfg_function_id; |
| 285 | u8 afg_unsol; |
| 286 | u8 mfg_unsol; |
| 287 | u32 vendor_id; |
| 288 | u32 subsystem_id; |
| 289 | u32 revision_id; |
| 290 | |
| 291 | /* detected preset */ |
| 292 | const struct hda_codec_preset *preset; |
| 293 | struct module *owner; |
| 294 | int (*parser)(struct hda_codec *codec); |
| 295 | const char *vendor_name; /* codec vendor name */ |
| 296 | const char *chip_name; /* codec chip name */ |
| 297 | const char *modelname; /* model name for preset */ |
| 298 | |
| 299 | /* set by patch */ |
| 300 | struct hda_codec_ops patch_ops; |
| 301 | |
| 302 | /* PCM to create, set by patch_ops.build_pcms callback */ |
| 303 | unsigned int num_pcms; |
| 304 | struct hda_pcm *pcm_info; |
| 305 | |
| 306 | /* codec specific info */ |
| 307 | void *spec; |
| 308 | |
| 309 | /* beep device */ |
| 310 | struct hda_beep *beep; |
| 311 | unsigned int beep_mode; |
| 312 | |
| 313 | /* widget capabilities cache */ |
| 314 | unsigned int num_nodes; |
| 315 | hda_nid_t start_nid; |
| 316 | u32 *wcaps; |
| 317 | |
| 318 | struct snd_array mixers; /* list of assigned mixer elements */ |
| 319 | struct snd_array nids; /* list of mapped mixer elements */ |
| 320 | |
| 321 | struct hda_cache_rec amp_cache; /* cache for amp access */ |
| 322 | struct hda_cache_rec cmd_cache; /* cache for other commands */ |
| 323 | |
| 324 | struct list_head conn_list; /* linked-list of connection-list */ |
| 325 | |
| 326 | struct mutex spdif_mutex; |
| 327 | struct mutex control_mutex; |
| 328 | struct mutex hash_mutex; |
| 329 | struct snd_array spdif_out; |
| 330 | unsigned int spdif_in_enable; /* SPDIF input enable? */ |
| 331 | const hda_nid_t *slave_dig_outs; /* optional digital out slave widgets */ |
| 332 | struct snd_array init_pins; /* initial (BIOS) pin configurations */ |
| 333 | struct snd_array driver_pins; /* pin configs set by codec parser */ |
| 334 | struct snd_array cvt_setups; /* audio convert setups */ |
| 335 | |
| 336 | struct mutex user_mutex; |
| 337 | #ifdef CONFIG_SND_HDA_RECONFIG |
| 338 | struct snd_array init_verbs; /* additional init verbs */ |
| 339 | struct snd_array hints; /* additional hints */ |
| 340 | struct snd_array user_pins; /* default pin configs to override */ |
| 341 | #endif |
| 342 | |
| 343 | #ifdef CONFIG_SND_HDA_HWDEP |
| 344 | struct snd_hwdep *hwdep; /* assigned hwdep device */ |
| 345 | #endif |
| 346 | |
| 347 | /* misc flags */ |
| 348 | unsigned int spdif_status_reset :1; /* needs to toggle SPDIF for each |
| 349 | * status change |
| 350 | * (e.g. Realtek codecs) |
| 351 | */ |
| 352 | unsigned int pin_amp_workaround:1; /* pin out-amp takes index |
| 353 | * (e.g. Conexant codecs) |
| 354 | */ |
| 355 | unsigned int single_adc_amp:1; /* adc in-amp takes no index |
| 356 | * (e.g. CX20549 codec) |
| 357 | */ |
| 358 | unsigned int no_sticky_stream:1; /* no sticky-PCM stream assignment */ |
| 359 | unsigned int pins_shutup:1; /* pins are shut up */ |
| 360 | unsigned int no_trigger_sense:1; /* don't trigger at pin-sensing */ |
| 361 | unsigned int no_jack_detect:1; /* Machine has no jack-detection */ |
| 362 | unsigned int inv_eapd:1; /* broken h/w: inverted EAPD control */ |
| 363 | unsigned int inv_jack_detect:1; /* broken h/w: inverted detection bit */ |
| 364 | unsigned int pcm_format_first:1; /* PCM format must be set first */ |
| 365 | unsigned int epss:1; /* supporting EPSS? */ |
| 366 | unsigned int cached_write:1; /* write only to caches */ |
| 367 | unsigned int dp_mst:1; /* support DP1.2 Multi-stream transport */ |
| 368 | unsigned int dump_coef:1; /* dump processing coefs in codec proc file */ |
| 369 | #ifdef CONFIG_PM |
| 370 | unsigned int power_on :1; /* current (global) power-state */ |
| 371 | unsigned int d3_stop_clk:1; /* support D3 operation without BCLK */ |
| 372 | unsigned int pm_up_notified:1; /* PM notified to controller */ |
| 373 | unsigned int in_pm:1; /* suspend/resume being performed */ |
| 374 | int power_transition; /* power-state in transition */ |
| 375 | int power_count; /* current (global) power refcount */ |
| 376 | struct delayed_work power_work; /* delayed task for powerdown */ |
| 377 | unsigned long power_on_acct; |
| 378 | unsigned long power_off_acct; |
| 379 | unsigned long power_jiffies; |
| 380 | spinlock_t power_lock; |
| 381 | #endif |
| 382 | |
| 383 | /* filter the requested power state per nid */ |
| 384 | unsigned int (*power_filter)(struct hda_codec *codec, hda_nid_t nid, |
| 385 | unsigned int power_state); |
| 386 | |
| 387 | /* codec-specific additional proc output */ |
| 388 | void (*proc_widget_hook)(struct snd_info_buffer *buffer, |
| 389 | struct hda_codec *codec, hda_nid_t nid); |
| 390 | |
| 391 | /* jack detection */ |
| 392 | struct snd_array jacktbl; |
| 393 | unsigned long jackpoll_interval; /* In jiffies. Zero means no poll, rely on unsol events */ |
| 394 | struct delayed_work jackpoll_work; |
| 395 | |
| 396 | #ifdef CONFIG_SND_HDA_INPUT_JACK |
| 397 | /* jack detection */ |
| 398 | struct snd_array jacks; |
| 399 | #endif |
| 400 | |
| 401 | int depop_delay; /* depop delay in ms, -1 for default delay time */ |
| 402 | |
| 403 | /* fix-up list */ |
| 404 | int fixup_id; |
| 405 | unsigned int fixup_forced:1; /* fixup explicitly set by user */ |
| 406 | const struct hda_fixup *fixup_list; |
| 407 | const char *fixup_name; |
| 408 | |
| 409 | /* additional init verbs */ |
| 410 | struct snd_array verbs; |
| 411 | }; |
| 412 | |
| 413 | /* direction */ |
| 414 | enum { |
| 415 | HDA_INPUT, HDA_OUTPUT |
| 416 | }; |
| 417 | |
| 418 | /* snd_hda_codec_read/write optional flags */ |
| 419 | #define HDA_RW_NO_RESPONSE_FALLBACK (1 << 0) |
| 420 | |
| 421 | /* |
| 422 | * constructors |
| 423 | */ |
| 424 | int snd_hda_bus_new(struct snd_card *card, const struct hda_bus_template *temp, |
| 425 | struct hda_bus **busp); |
| 426 | int snd_hda_codec_new(struct hda_bus *bus, unsigned int codec_addr, |
| 427 | struct hda_codec **codecp); |
| 428 | int snd_hda_codec_configure(struct hda_codec *codec); |
| 429 | int snd_hda_codec_update_widgets(struct hda_codec *codec); |
| 430 | |
| 431 | /* |
| 432 | * low level functions |
| 433 | */ |
| 434 | unsigned int snd_hda_codec_read(struct hda_codec *codec, hda_nid_t nid, |
| 435 | int flags, |
| 436 | unsigned int verb, unsigned int parm); |
| 437 | int snd_hda_codec_write(struct hda_codec *codec, hda_nid_t nid, int flags, |
| 438 | unsigned int verb, unsigned int parm); |
| 439 | #define snd_hda_param_read(codec, nid, param) \ |
| 440 | snd_hda_codec_read(codec, nid, 0, AC_VERB_PARAMETERS, param) |
| 441 | int snd_hda_get_sub_nodes(struct hda_codec *codec, hda_nid_t nid, |
| 442 | hda_nid_t *start_id); |
| 443 | int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid, |
| 444 | hda_nid_t *conn_list, int max_conns); |
| 445 | static inline int |
| 446 | snd_hda_get_num_conns(struct hda_codec *codec, hda_nid_t nid) |
| 447 | { |
| 448 | return snd_hda_get_connections(codec, nid, NULL, 0); |
| 449 | } |
| 450 | int snd_hda_get_num_raw_conns(struct hda_codec *codec, hda_nid_t nid); |
| 451 | int snd_hda_get_raw_connections(struct hda_codec *codec, hda_nid_t nid, |
| 452 | hda_nid_t *conn_list, int max_conns); |
| 453 | int snd_hda_get_conn_list(struct hda_codec *codec, hda_nid_t nid, |
| 454 | const hda_nid_t **listp); |
| 455 | int snd_hda_override_conn_list(struct hda_codec *codec, hda_nid_t nid, int nums, |
| 456 | const hda_nid_t *list); |
| 457 | int snd_hda_get_conn_index(struct hda_codec *codec, hda_nid_t mux, |
| 458 | hda_nid_t nid, int recursive); |
| 459 | int snd_hda_get_devices(struct hda_codec *codec, hda_nid_t nid, |
| 460 | u8 *dev_list, int max_devices); |
| 461 | int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid, |
| 462 | u32 *ratesp, u64 *formatsp, unsigned int *bpsp); |
| 463 | |
| 464 | struct hda_verb { |
| 465 | hda_nid_t nid; |
| 466 | u32 verb; |
| 467 | u32 param; |
| 468 | }; |
| 469 | |
| 470 | void snd_hda_sequence_write(struct hda_codec *codec, |
| 471 | const struct hda_verb *seq); |
| 472 | |
| 473 | /* unsolicited event */ |
| 474 | int snd_hda_queue_unsol_event(struct hda_bus *bus, u32 res, u32 res_ex); |
| 475 | |
| 476 | /* cached write */ |
| 477 | int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid, |
| 478 | int flags, unsigned int verb, unsigned int parm); |
| 479 | void snd_hda_sequence_write_cache(struct hda_codec *codec, |
| 480 | const struct hda_verb *seq); |
| 481 | int snd_hda_codec_update_cache(struct hda_codec *codec, hda_nid_t nid, |
| 482 | int flags, unsigned int verb, unsigned int parm); |
| 483 | void snd_hda_codec_resume_cache(struct hda_codec *codec); |
| 484 | /* both for cmd & amp caches */ |
| 485 | void snd_hda_codec_flush_cache(struct hda_codec *codec); |
| 486 | |
| 487 | /* the struct for codec->pin_configs */ |
| 488 | struct hda_pincfg { |
| 489 | hda_nid_t nid; |
| 490 | unsigned char ctrl; /* original pin control value */ |
| 491 | unsigned char target; /* target pin control value */ |
| 492 | unsigned int cfg; /* default configuration */ |
| 493 | }; |
| 494 | |
| 495 | unsigned int snd_hda_codec_get_pincfg(struct hda_codec *codec, hda_nid_t nid); |
| 496 | int snd_hda_codec_set_pincfg(struct hda_codec *codec, hda_nid_t nid, |
| 497 | unsigned int cfg); |
| 498 | int snd_hda_add_pincfg(struct hda_codec *codec, struct snd_array *list, |
| 499 | hda_nid_t nid, unsigned int cfg); /* for hwdep */ |
| 500 | void snd_hda_shutup_pins(struct hda_codec *codec); |
| 501 | |
| 502 | /* SPDIF controls */ |
| 503 | struct hda_spdif_out { |
| 504 | hda_nid_t nid; /* Converter nid values relate to */ |
| 505 | unsigned int status; /* IEC958 status bits */ |
| 506 | unsigned short ctls; /* SPDIF control bits */ |
| 507 | }; |
| 508 | struct hda_spdif_out *snd_hda_spdif_out_of_nid(struct hda_codec *codec, |
| 509 | hda_nid_t nid); |
| 510 | void snd_hda_spdif_ctls_unassign(struct hda_codec *codec, int idx); |
| 511 | void snd_hda_spdif_ctls_assign(struct hda_codec *codec, int idx, hda_nid_t nid); |
| 512 | |
| 513 | /* |
| 514 | * Mixer |
| 515 | */ |
| 516 | int snd_hda_build_controls(struct hda_bus *bus); |
| 517 | int snd_hda_codec_build_controls(struct hda_codec *codec); |
| 518 | |
| 519 | /* |
| 520 | * PCM |
| 521 | */ |
| 522 | int snd_hda_build_pcms(struct hda_bus *bus); |
| 523 | int snd_hda_codec_build_pcms(struct hda_codec *codec); |
| 524 | |
| 525 | int snd_hda_codec_prepare(struct hda_codec *codec, |
| 526 | struct hda_pcm_stream *hinfo, |
| 527 | unsigned int stream, |
| 528 | unsigned int format, |
| 529 | struct snd_pcm_substream *substream); |
| 530 | void snd_hda_codec_cleanup(struct hda_codec *codec, |
| 531 | struct hda_pcm_stream *hinfo, |
| 532 | struct snd_pcm_substream *substream); |
| 533 | |
| 534 | void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid, |
| 535 | u32 stream_tag, |
| 536 | int channel_id, int format); |
| 537 | void __snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid, |
| 538 | int do_now); |
| 539 | #define snd_hda_codec_cleanup_stream(codec, nid) \ |
| 540 | __snd_hda_codec_cleanup_stream(codec, nid, 0) |
| 541 | unsigned int snd_hda_calc_stream_format(unsigned int rate, |
| 542 | unsigned int channels, |
| 543 | unsigned int format, |
| 544 | unsigned int maxbps, |
| 545 | unsigned short spdif_ctls); |
| 546 | int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid, |
| 547 | unsigned int format); |
| 548 | |
| 549 | extern const struct snd_pcm_chmap_elem snd_pcm_2_1_chmaps[]; |
| 550 | |
| 551 | /* |
| 552 | * Misc |
| 553 | */ |
| 554 | void snd_hda_get_codec_name(struct hda_codec *codec, char *name, int namelen); |
| 555 | void snd_hda_bus_reboot_notify(struct hda_bus *bus); |
| 556 | void snd_hda_codec_set_power_to_all(struct hda_codec *codec, hda_nid_t fg, |
| 557 | unsigned int power_state); |
| 558 | |
| 559 | int snd_hda_lock_devices(struct hda_bus *bus); |
| 560 | void snd_hda_unlock_devices(struct hda_bus *bus); |
| 561 | |
| 562 | /* |
| 563 | * power management |
| 564 | */ |
| 565 | #ifdef CONFIG_PM |
| 566 | int snd_hda_suspend(struct hda_bus *bus); |
| 567 | int snd_hda_resume(struct hda_bus *bus); |
| 568 | #endif |
| 569 | |
| 570 | static inline |
| 571 | int hda_call_check_power_status(struct hda_codec *codec, hda_nid_t nid) |
| 572 | { |
| 573 | #ifdef CONFIG_PM |
| 574 | if (codec->patch_ops.check_power_status) |
| 575 | return codec->patch_ops.check_power_status(codec, nid); |
| 576 | #endif |
| 577 | return 0; |
| 578 | } |
| 579 | |
| 580 | /* |
| 581 | * get widget information |
| 582 | */ |
| 583 | const char *snd_hda_get_jack_connectivity(u32 cfg); |
| 584 | const char *snd_hda_get_jack_type(u32 cfg); |
| 585 | const char *snd_hda_get_jack_location(u32 cfg); |
| 586 | |
| 587 | /* |
| 588 | * power saving |
| 589 | */ |
| 590 | #ifdef CONFIG_PM |
| 591 | void snd_hda_power_save(struct hda_codec *codec, int delta, bool d3wait); |
| 592 | void snd_hda_update_power_acct(struct hda_codec *codec); |
| 593 | #else |
| 594 | static inline void snd_hda_power_save(struct hda_codec *codec, int delta, |
| 595 | bool d3wait) {} |
| 596 | #endif |
| 597 | |
| 598 | /** |
| 599 | * snd_hda_power_up - Power-up the codec |
| 600 | * @codec: HD-audio codec |
| 601 | * |
| 602 | * Increment the power-up counter and power up the hardware really when |
| 603 | * not turned on yet. |
| 604 | */ |
| 605 | static inline void snd_hda_power_up(struct hda_codec *codec) |
| 606 | { |
| 607 | snd_hda_power_save(codec, 1, false); |
| 608 | } |
| 609 | |
| 610 | /** |
| 611 | * snd_hda_power_up_d3wait - Power-up the codec after waiting for any pending |
| 612 | * D3 transition to complete. This differs from snd_hda_power_up() when |
| 613 | * power_transition == -1. snd_hda_power_up sees this case as a nop, |
| 614 | * snd_hda_power_up_d3wait waits for the D3 transition to complete then powers |
| 615 | * back up. |
| 616 | * @codec: HD-audio codec |
| 617 | * |
| 618 | * Cancel any power down operation hapenning on the work queue, then power up. |
| 619 | */ |
| 620 | static inline void snd_hda_power_up_d3wait(struct hda_codec *codec) |
| 621 | { |
| 622 | snd_hda_power_save(codec, 1, true); |
| 623 | } |
| 624 | |
| 625 | /** |
| 626 | * snd_hda_power_down - Power-down the codec |
| 627 | * @codec: HD-audio codec |
| 628 | * |
| 629 | * Decrement the power-up counter and schedules the power-off work if |
| 630 | * the counter rearches to zero. |
| 631 | */ |
| 632 | static inline void snd_hda_power_down(struct hda_codec *codec) |
| 633 | { |
| 634 | snd_hda_power_save(codec, -1, false); |
| 635 | } |
| 636 | |
| 637 | /** |
| 638 | * snd_hda_power_sync - Synchronize the power-save status |
| 639 | * @codec: HD-audio codec |
| 640 | * |
| 641 | * Synchronize the actual power state with the power account; |
| 642 | * called when power_save parameter is changed |
| 643 | */ |
| 644 | static inline void snd_hda_power_sync(struct hda_codec *codec) |
| 645 | { |
| 646 | snd_hda_power_save(codec, 0, false); |
| 647 | } |
| 648 | |
| 649 | #ifdef CONFIG_SND_HDA_PATCH_LOADER |
| 650 | /* |
| 651 | * patch firmware |
| 652 | */ |
| 653 | int snd_hda_load_patch(struct hda_bus *bus, size_t size, const void *buf); |
| 654 | #endif |
| 655 | |
| 656 | #ifdef CONFIG_SND_HDA_DSP_LOADER |
| 657 | static inline int |
| 658 | snd_hda_codec_load_dsp_prepare(struct hda_codec *codec, unsigned int format, |
| 659 | unsigned int size, |
| 660 | struct snd_dma_buffer *bufp) |
| 661 | { |
| 662 | return codec->bus->ops.load_dsp_prepare(codec->bus, format, size, bufp); |
| 663 | } |
| 664 | static inline void |
| 665 | snd_hda_codec_load_dsp_trigger(struct hda_codec *codec, bool start) |
| 666 | { |
| 667 | return codec->bus->ops.load_dsp_trigger(codec->bus, start); |
| 668 | } |
| 669 | static inline void |
| 670 | snd_hda_codec_load_dsp_cleanup(struct hda_codec *codec, |
| 671 | struct snd_dma_buffer *dmab) |
| 672 | { |
| 673 | return codec->bus->ops.load_dsp_cleanup(codec->bus, dmab); |
| 674 | } |
| 675 | #else |
| 676 | static inline int |
| 677 | snd_hda_codec_load_dsp_prepare(struct hda_codec *codec, unsigned int format, |
| 678 | unsigned int size, |
| 679 | struct snd_dma_buffer *bufp) |
| 680 | { |
| 681 | return -ENOSYS; |
| 682 | } |
| 683 | static inline void |
| 684 | snd_hda_codec_load_dsp_trigger(struct hda_codec *codec, bool start) {} |
| 685 | static inline void |
| 686 | snd_hda_codec_load_dsp_cleanup(struct hda_codec *codec, |
| 687 | struct snd_dma_buffer *dmab) {} |
| 688 | #endif |
| 689 | |
| 690 | #define EXPORT_SYMBOL_HDA(sym) EXPORT_SYMBOL_GPL(sym) |
| 691 | |
| 692 | #endif /* __SOUND_HDA_CODEC_H */ |