1 /* SPDX-License-Identifier: GPL-2.0-or-later */ 2 #ifndef __SOUND_PCM_H 3 #define __SOUND_PCM_H 4 5 /* 6 * Digital Audio (PCM) abstract layer 7 * Copyright (c) by Jaroslav Kysela <perex@perex.cz> 8 * Abramo Bagnara <abramo@alsa-project.org> 9 */ 10 11 #include <sound/asound.h> 12 #include <sound/memalloc.h> 13 #include <sound/minors.h> 14 #include <linux/poll.h> 15 #include <linux/mm.h> 16 #include <linux/bitops.h> 17 #include <linux/pm_qos.h> 18 #include <linux/refcount.h> 19 #include <linux/uio.h> 20 21 #define snd_pcm_substream_chip(substream) ((substream)->private_data) 22 #define snd_pcm_chip(pcm) ((pcm)->private_data) 23 24 #if IS_ENABLED(CONFIG_SND_PCM_OSS) 25 #include <sound/pcm_oss.h> 26 #endif 27 28 /* 29 * Hardware (lowlevel) section 30 */ 31 32 struct snd_pcm_hardware { 33 unsigned int info; /* SNDRV_PCM_INFO_* */ 34 u64 formats; /* SNDRV_PCM_FMTBIT_* */ 35 u32 subformats; /* for S32_LE, SNDRV_PCM_SUBFMTBIT_* */ 36 unsigned int rates; /* SNDRV_PCM_RATE_* */ 37 unsigned int rate_min; /* min rate */ 38 unsigned int rate_max; /* max rate */ 39 unsigned int channels_min; /* min channels */ 40 unsigned int channels_max; /* max channels */ 41 size_t buffer_bytes_max; /* max buffer size */ 42 size_t period_bytes_min; /* min period size */ 43 size_t period_bytes_max; /* max period size */ 44 unsigned int periods_min; /* min # of periods */ 45 unsigned int periods_max; /* max # of periods */ 46 size_t fifo_size; /* fifo size in bytes */ 47 }; 48 49 struct snd_pcm_status64; 50 struct snd_pcm_substream; 51 52 struct snd_pcm_audio_tstamp_config; /* definitions further down */ 53 struct snd_pcm_audio_tstamp_report; 54 55 struct snd_pcm_ops { 56 int (*open)(struct snd_pcm_substream *substream); 57 int (*close)(struct snd_pcm_substream *substream); 58 int (*ioctl)(struct snd_pcm_substream * substream, 59 unsigned int cmd, void *arg); 60 int (*hw_params)(struct snd_pcm_substream *substream, 61 struct snd_pcm_hw_params *params); 62 int (*hw_free)(struct snd_pcm_substream *substream); 63 int (*prepare)(struct snd_pcm_substream *substream); 64 int (*trigger)(struct snd_pcm_substream *substream, int cmd); 65 int (*sync_stop)(struct snd_pcm_substream *substream); 66 snd_pcm_uframes_t (*pointer)(struct snd_pcm_substream *substream); 67 int (*get_time_info)(struct snd_pcm_substream *substream, 68 struct timespec64 *system_ts, struct timespec64 *audio_ts, 69 struct snd_pcm_audio_tstamp_config *audio_tstamp_config, 70 struct snd_pcm_audio_tstamp_report *audio_tstamp_report); 71 int (*fill_silence)(struct snd_pcm_substream *substream, int channel, 72 unsigned long pos, unsigned long bytes); 73 int (*copy)(struct snd_pcm_substream *substream, int channel, 74 unsigned long pos, struct iov_iter *iter, unsigned long bytes); 75 struct page *(*page)(struct snd_pcm_substream *substream, 76 unsigned long offset); 77 int (*mmap)(struct snd_pcm_substream *substream, struct vm_area_struct *vma); 78 int (*ack)(struct snd_pcm_substream *substream); 79 }; 80 81 /* 82 * 83 */ 84 85 #if defined(CONFIG_SND_DYNAMIC_MINORS) 86 #define SNDRV_PCM_DEVICES (SNDRV_OS_MINORS-2) 87 #else 88 #define SNDRV_PCM_DEVICES 8 89 #endif 90 91 #define SNDRV_PCM_IOCTL1_RESET 0 92 /* 1 is absent slot. */ 93 #define SNDRV_PCM_IOCTL1_CHANNEL_INFO 2 94 /* 3 is absent slot. */ 95 #define SNDRV_PCM_IOCTL1_FIFO_SIZE 4 96 #define SNDRV_PCM_IOCTL1_SYNC_ID 5 97 98 #define SNDRV_PCM_TRIGGER_STOP 0 99 #define SNDRV_PCM_TRIGGER_START 1 100 #define SNDRV_PCM_TRIGGER_PAUSE_PUSH 3 101 #define SNDRV_PCM_TRIGGER_PAUSE_RELEASE 4 102 #define SNDRV_PCM_TRIGGER_SUSPEND 5 103 #define SNDRV_PCM_TRIGGER_RESUME 6 104 #define SNDRV_PCM_TRIGGER_DRAIN 7 105 106 #define SNDRV_PCM_POS_XRUN ((snd_pcm_uframes_t)-1) 107 108 /* If you change this don't forget to change rates[] table in pcm_native.c */ 109 #define SNDRV_PCM_RATE_5512 (1U<<0) /* 5512Hz */ 110 #define SNDRV_PCM_RATE_8000 (1U<<1) /* 8000Hz */ 111 #define SNDRV_PCM_RATE_11025 (1U<<2) /* 11025Hz */ 112 #define SNDRV_PCM_RATE_16000 (1U<<3) /* 16000Hz */ 113 #define SNDRV_PCM_RATE_22050 (1U<<4) /* 22050Hz */ 114 #define SNDRV_PCM_RATE_32000 (1U<<5) /* 32000Hz */ 115 #define SNDRV_PCM_RATE_44100 (1U<<6) /* 44100Hz */ 116 #define SNDRV_PCM_RATE_48000 (1U<<7) /* 48000Hz */ 117 #define SNDRV_PCM_RATE_64000 (1U<<8) /* 64000Hz */ 118 #define SNDRV_PCM_RATE_88200 (1U<<9) /* 88200Hz */ 119 #define SNDRV_PCM_RATE_96000 (1U<<10) /* 96000Hz */ 120 #define SNDRV_PCM_RATE_176400 (1U<<11) /* 176400Hz */ 121 #define SNDRV_PCM_RATE_192000 (1U<<12) /* 192000Hz */ 122 #define SNDRV_PCM_RATE_352800 (1U<<13) /* 352800Hz */ 123 #define SNDRV_PCM_RATE_384000 (1U<<14) /* 384000Hz */ 124 #define SNDRV_PCM_RATE_705600 (1U<<15) /* 705600Hz */ 125 #define SNDRV_PCM_RATE_768000 (1U<<16) /* 768000Hz */ 126 127 #define SNDRV_PCM_RATE_CONTINUOUS (1U<<30) /* continuous range */ 128 #define SNDRV_PCM_RATE_KNOT (1U<<31) /* supports more non-continuous rates */ 129 130 #define SNDRV_PCM_RATE_8000_44100 (SNDRV_PCM_RATE_8000|SNDRV_PCM_RATE_11025|\ 131 SNDRV_PCM_RATE_16000|SNDRV_PCM_RATE_22050|\ 132 SNDRV_PCM_RATE_32000|SNDRV_PCM_RATE_44100) 133 #define SNDRV_PCM_RATE_8000_48000 (SNDRV_PCM_RATE_8000_44100|SNDRV_PCM_RATE_48000) 134 #define SNDRV_PCM_RATE_8000_96000 (SNDRV_PCM_RATE_8000_48000|SNDRV_PCM_RATE_64000|\ 135 SNDRV_PCM_RATE_88200|SNDRV_PCM_RATE_96000) 136 #define SNDRV_PCM_RATE_8000_192000 (SNDRV_PCM_RATE_8000_96000|SNDRV_PCM_RATE_176400|\ 137 SNDRV_PCM_RATE_192000) 138 #define SNDRV_PCM_RATE_8000_384000 (SNDRV_PCM_RATE_8000_192000|\ 139 SNDRV_PCM_RATE_352800|\ 140 SNDRV_PCM_RATE_384000) 141 #define SNDRV_PCM_RATE_8000_768000 (SNDRV_PCM_RATE_8000_384000|\ 142 SNDRV_PCM_RATE_705600|\ 143 SNDRV_PCM_RATE_768000) 144 #define _SNDRV_PCM_FMTBIT(fmt) (1ULL << (__force int)SNDRV_PCM_FORMAT_##fmt) 145 #define SNDRV_PCM_FMTBIT_S8 _SNDRV_PCM_FMTBIT(S8) 146 #define SNDRV_PCM_FMTBIT_U8 _SNDRV_PCM_FMTBIT(U8) 147 #define SNDRV_PCM_FMTBIT_S16_LE _SNDRV_PCM_FMTBIT(S16_LE) 148 #define SNDRV_PCM_FMTBIT_S16_BE _SNDRV_PCM_FMTBIT(S16_BE) 149 #define SNDRV_PCM_FMTBIT_U16_LE _SNDRV_PCM_FMTBIT(U16_LE) 150 #define SNDRV_PCM_FMTBIT_U16_BE _SNDRV_PCM_FMTBIT(U16_BE) 151 #define SNDRV_PCM_FMTBIT_S24_LE _SNDRV_PCM_FMTBIT(S24_LE) 152 #define SNDRV_PCM_FMTBIT_S24_BE _SNDRV_PCM_FMTBIT(S24_BE) 153 #define SNDRV_PCM_FMTBIT_U24_LE _SNDRV_PCM_FMTBIT(U24_LE) 154 #define SNDRV_PCM_FMTBIT_U24_BE _SNDRV_PCM_FMTBIT(U24_BE) 155 // For S32/U32 formats, 'msbits' hardware parameter is often used to deliver information about the 156 // available bit count in most significant bit. It's for the case of so-called 'left-justified' or 157 // `right-padding` sample which has less width than 32 bit. 158 #define SNDRV_PCM_FMTBIT_S32_LE _SNDRV_PCM_FMTBIT(S32_LE) 159 #define SNDRV_PCM_FMTBIT_S32_BE _SNDRV_PCM_FMTBIT(S32_BE) 160 #define SNDRV_PCM_FMTBIT_U32_LE _SNDRV_PCM_FMTBIT(U32_LE) 161 #define SNDRV_PCM_FMTBIT_U32_BE _SNDRV_PCM_FMTBIT(U32_BE) 162 #define SNDRV_PCM_FMTBIT_FLOAT_LE _SNDRV_PCM_FMTBIT(FLOAT_LE) 163 #define SNDRV_PCM_FMTBIT_FLOAT_BE _SNDRV_PCM_FMTBIT(FLOAT_BE) 164 #define SNDRV_PCM_FMTBIT_FLOAT64_LE _SNDRV_PCM_FMTBIT(FLOAT64_LE) 165 #define SNDRV_PCM_FMTBIT_FLOAT64_BE _SNDRV_PCM_FMTBIT(FLOAT64_BE) 166 #define SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE _SNDRV_PCM_FMTBIT(IEC958_SUBFRAME_LE) 167 #define SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_BE _SNDRV_PCM_FMTBIT(IEC958_SUBFRAME_BE) 168 #define SNDRV_PCM_FMTBIT_MU_LAW _SNDRV_PCM_FMTBIT(MU_LAW) 169 #define SNDRV_PCM_FMTBIT_A_LAW _SNDRV_PCM_FMTBIT(A_LAW) 170 #define SNDRV_PCM_FMTBIT_IMA_ADPCM _SNDRV_PCM_FMTBIT(IMA_ADPCM) 171 #define SNDRV_PCM_FMTBIT_MPEG _SNDRV_PCM_FMTBIT(MPEG) 172 #define SNDRV_PCM_FMTBIT_GSM _SNDRV_PCM_FMTBIT(GSM) 173 #define SNDRV_PCM_FMTBIT_S20_LE _SNDRV_PCM_FMTBIT(S20_LE) 174 #define SNDRV_PCM_FMTBIT_U20_LE _SNDRV_PCM_FMTBIT(U20_LE) 175 #define SNDRV_PCM_FMTBIT_S20_BE _SNDRV_PCM_FMTBIT(S20_BE) 176 #define SNDRV_PCM_FMTBIT_U20_BE _SNDRV_PCM_FMTBIT(U20_BE) 177 #define SNDRV_PCM_FMTBIT_SPECIAL _SNDRV_PCM_FMTBIT(SPECIAL) 178 #define SNDRV_PCM_FMTBIT_S24_3LE _SNDRV_PCM_FMTBIT(S24_3LE) 179 #define SNDRV_PCM_FMTBIT_U24_3LE _SNDRV_PCM_FMTBIT(U24_3LE) 180 #define SNDRV_PCM_FMTBIT_S24_3BE _SNDRV_PCM_FMTBIT(S24_3BE) 181 #define SNDRV_PCM_FMTBIT_U24_3BE _SNDRV_PCM_FMTBIT(U24_3BE) 182 #define SNDRV_PCM_FMTBIT_S20_3LE _SNDRV_PCM_FMTBIT(S20_3LE) 183 #define SNDRV_PCM_FMTBIT_U20_3LE _SNDRV_PCM_FMTBIT(U20_3LE) 184 #define SNDRV_PCM_FMTBIT_S20_3BE _SNDRV_PCM_FMTBIT(S20_3BE) 185 #define SNDRV_PCM_FMTBIT_U20_3BE _SNDRV_PCM_FMTBIT(U20_3BE) 186 #define SNDRV_PCM_FMTBIT_S18_3LE _SNDRV_PCM_FMTBIT(S18_3LE) 187 #define SNDRV_PCM_FMTBIT_U18_3LE _SNDRV_PCM_FMTBIT(U18_3LE) 188 #define SNDRV_PCM_FMTBIT_S18_3BE _SNDRV_PCM_FMTBIT(S18_3BE) 189 #define SNDRV_PCM_FMTBIT_U18_3BE _SNDRV_PCM_FMTBIT(U18_3BE) 190 #define SNDRV_PCM_FMTBIT_G723_24 _SNDRV_PCM_FMTBIT(G723_24) 191 #define SNDRV_PCM_FMTBIT_G723_24_1B _SNDRV_PCM_FMTBIT(G723_24_1B) 192 #define SNDRV_PCM_FMTBIT_G723_40 _SNDRV_PCM_FMTBIT(G723_40) 193 #define SNDRV_PCM_FMTBIT_G723_40_1B _SNDRV_PCM_FMTBIT(G723_40_1B) 194 #define SNDRV_PCM_FMTBIT_DSD_U8 _SNDRV_PCM_FMTBIT(DSD_U8) 195 #define SNDRV_PCM_FMTBIT_DSD_U16_LE _SNDRV_PCM_FMTBIT(DSD_U16_LE) 196 #define SNDRV_PCM_FMTBIT_DSD_U32_LE _SNDRV_PCM_FMTBIT(DSD_U32_LE) 197 #define SNDRV_PCM_FMTBIT_DSD_U16_BE _SNDRV_PCM_FMTBIT(DSD_U16_BE) 198 #define SNDRV_PCM_FMTBIT_DSD_U32_BE _SNDRV_PCM_FMTBIT(DSD_U32_BE) 199 200 #ifdef SNDRV_LITTLE_ENDIAN 201 #define SNDRV_PCM_FMTBIT_S16 SNDRV_PCM_FMTBIT_S16_LE 202 #define SNDRV_PCM_FMTBIT_U16 SNDRV_PCM_FMTBIT_U16_LE 203 #define SNDRV_PCM_FMTBIT_S24 SNDRV_PCM_FMTBIT_S24_LE 204 #define SNDRV_PCM_FMTBIT_U24 SNDRV_PCM_FMTBIT_U24_LE 205 #define SNDRV_PCM_FMTBIT_S32 SNDRV_PCM_FMTBIT_S32_LE 206 #define SNDRV_PCM_FMTBIT_U32 SNDRV_PCM_FMTBIT_U32_LE 207 #define SNDRV_PCM_FMTBIT_FLOAT SNDRV_PCM_FMTBIT_FLOAT_LE 208 #define SNDRV_PCM_FMTBIT_FLOAT64 SNDRV_PCM_FMTBIT_FLOAT64_LE 209 #define SNDRV_PCM_FMTBIT_IEC958_SUBFRAME SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE 210 #define SNDRV_PCM_FMTBIT_S20 SNDRV_PCM_FMTBIT_S20_LE 211 #define SNDRV_PCM_FMTBIT_U20 SNDRV_PCM_FMTBIT_U20_LE 212 #endif 213 #ifdef SNDRV_BIG_ENDIAN 214 #define SNDRV_PCM_FMTBIT_S16 SNDRV_PCM_FMTBIT_S16_BE 215 #define SNDRV_PCM_FMTBIT_U16 SNDRV_PCM_FMTBIT_U16_BE 216 #define SNDRV_PCM_FMTBIT_S24 SNDRV_PCM_FMTBIT_S24_BE 217 #define SNDRV_PCM_FMTBIT_U24 SNDRV_PCM_FMTBIT_U24_BE 218 #define SNDRV_PCM_FMTBIT_S32 SNDRV_PCM_FMTBIT_S32_BE 219 #define SNDRV_PCM_FMTBIT_U32 SNDRV_PCM_FMTBIT_U32_BE 220 #define SNDRV_PCM_FMTBIT_FLOAT SNDRV_PCM_FMTBIT_FLOAT_BE 221 #define SNDRV_PCM_FMTBIT_FLOAT64 SNDRV_PCM_FMTBIT_FLOAT64_BE 222 #define SNDRV_PCM_FMTBIT_IEC958_SUBFRAME SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_BE 223 #define SNDRV_PCM_FMTBIT_S20 SNDRV_PCM_FMTBIT_S20_BE 224 #define SNDRV_PCM_FMTBIT_U20 SNDRV_PCM_FMTBIT_U20_BE 225 #endif 226 227 #define _SNDRV_PCM_SUBFMTBIT(fmt) BIT((__force int)SNDRV_PCM_SUBFORMAT_##fmt) 228 #define SNDRV_PCM_SUBFMTBIT_STD _SNDRV_PCM_SUBFMTBIT(STD) 229 #define SNDRV_PCM_SUBFMTBIT_MSBITS_MAX _SNDRV_PCM_SUBFMTBIT(MSBITS_MAX) 230 #define SNDRV_PCM_SUBFMTBIT_MSBITS_20 _SNDRV_PCM_SUBFMTBIT(MSBITS_20) 231 #define SNDRV_PCM_SUBFMTBIT_MSBITS_24 _SNDRV_PCM_SUBFMTBIT(MSBITS_24) 232 233 struct snd_pcm_file { 234 struct snd_pcm_substream *substream; 235 int no_compat_mmap; 236 unsigned int user_pversion; /* supported protocol version */ 237 }; 238 239 struct snd_pcm_hw_rule; 240 typedef int (*snd_pcm_hw_rule_func_t)(struct snd_pcm_hw_params *params, 241 struct snd_pcm_hw_rule *rule); 242 243 struct snd_pcm_hw_rule { 244 unsigned int cond; 245 int var; 246 int deps[5]; 247 248 snd_pcm_hw_rule_func_t func; 249 void *private; 250 }; 251 252 struct snd_pcm_hw_constraints { 253 struct snd_mask masks[SNDRV_PCM_HW_PARAM_LAST_MASK - 254 SNDRV_PCM_HW_PARAM_FIRST_MASK + 1]; 255 struct snd_interval intervals[SNDRV_PCM_HW_PARAM_LAST_INTERVAL - 256 SNDRV_PCM_HW_PARAM_FIRST_INTERVAL + 1]; 257 unsigned int rules_num; 258 unsigned int rules_all; 259 struct snd_pcm_hw_rule *rules; 260 }; 261 262 static inline struct snd_mask *constrs_mask(struct snd_pcm_hw_constraints *constrs, 263 snd_pcm_hw_param_t var) 264 { 265 return &constrs->masks[var - SNDRV_PCM_HW_PARAM_FIRST_MASK]; 266 } 267 268 static inline struct snd_interval *constrs_interval(struct snd_pcm_hw_constraints *constrs, 269 snd_pcm_hw_param_t var) 270 { 271 return &constrs->intervals[var - SNDRV_PCM_HW_PARAM_FIRST_INTERVAL]; 272 } 273 274 struct snd_ratnum { 275 unsigned int num; 276 unsigned int den_min, den_max, den_step; 277 }; 278 279 struct snd_ratden { 280 unsigned int num_min, num_max, num_step; 281 unsigned int den; 282 }; 283 284 struct snd_pcm_hw_constraint_ratnums { 285 int nrats; 286 const struct snd_ratnum *rats; 287 }; 288 289 struct snd_pcm_hw_constraint_ratdens { 290 int nrats; 291 const struct snd_ratden *rats; 292 }; 293 294 struct snd_pcm_hw_constraint_list { 295 const unsigned int *list; 296 unsigned int count; 297 unsigned int mask; 298 }; 299 300 struct snd_pcm_hw_constraint_ranges { 301 unsigned int count; 302 const struct snd_interval *ranges; 303 unsigned int mask; 304 }; 305 306 /* 307 * userspace-provided audio timestamp config to kernel, 308 * structure is for internal use only and filled with dedicated unpack routine 309 */ 310 struct snd_pcm_audio_tstamp_config { 311 /* 5 of max 16 bits used */ 312 u32 type_requested:4; 313 u32 report_delay:1; /* add total delay to A/D or D/A */ 314 }; 315 316 static inline void snd_pcm_unpack_audio_tstamp_config(__u32 data, 317 struct snd_pcm_audio_tstamp_config *config) 318 { 319 config->type_requested = data & 0xF; 320 config->report_delay = (data >> 4) & 1; 321 } 322 323 /* 324 * kernel-provided audio timestamp report to user-space 325 * structure is for internal use only and read by dedicated pack routine 326 */ 327 struct snd_pcm_audio_tstamp_report { 328 /* 6 of max 16 bits used for bit-fields */ 329 330 /* for backwards compatibility */ 331 u32 valid:1; 332 333 /* actual type if hardware could not support requested timestamp */ 334 u32 actual_type:4; 335 336 /* accuracy represented in ns units */ 337 u32 accuracy_report:1; /* 0 if accuracy unknown, 1 if accuracy field is valid */ 338 u32 accuracy; /* up to 4.29s, will be packed in separate field */ 339 }; 340 341 static inline void snd_pcm_pack_audio_tstamp_report(__u32 *data, __u32 *accuracy, 342 const struct snd_pcm_audio_tstamp_report *report) 343 { 344 u32 tmp; 345 346 tmp = report->accuracy_report; 347 tmp <<= 4; 348 tmp |= report->actual_type; 349 tmp <<= 1; 350 tmp |= report->valid; 351 352 *data &= 0xffff; /* zero-clear MSBs */ 353 *data |= (tmp << 16); 354 *accuracy = report->accuracy; 355 } 356 357 358 struct snd_pcm_runtime { 359 /* -- Status -- */ 360 snd_pcm_state_t state; /* stream state */ 361 snd_pcm_state_t suspended_state; /* suspended stream state */ 362 struct snd_pcm_substream *trigger_master; 363 struct timespec64 trigger_tstamp; /* trigger timestamp */ 364 bool trigger_tstamp_latched; /* trigger timestamp latched in low-level driver/hardware */ 365 int overrange; 366 snd_pcm_uframes_t avail_max; 367 snd_pcm_uframes_t hw_ptr_base; /* Position at buffer restart */ 368 snd_pcm_uframes_t hw_ptr_interrupt; /* Position at interrupt time */ 369 unsigned long hw_ptr_jiffies; /* Time when hw_ptr is updated */ 370 unsigned long hw_ptr_buffer_jiffies; /* buffer time in jiffies */ 371 snd_pcm_sframes_t delay; /* extra delay; typically FIFO size */ 372 u64 hw_ptr_wrap; /* offset for hw_ptr due to boundary wrap-around */ 373 374 /* -- HW params -- */ 375 snd_pcm_access_t access; /* access mode */ 376 snd_pcm_format_t format; /* SNDRV_PCM_FORMAT_* */ 377 snd_pcm_subformat_t subformat; /* subformat */ 378 unsigned int rate; /* rate in Hz */ 379 unsigned int channels; /* channels */ 380 snd_pcm_uframes_t period_size; /* period size */ 381 unsigned int periods; /* periods */ 382 snd_pcm_uframes_t buffer_size; /* buffer size */ 383 snd_pcm_uframes_t min_align; /* Min alignment for the format */ 384 size_t byte_align; 385 unsigned int frame_bits; 386 unsigned int sample_bits; 387 unsigned int info; 388 unsigned int rate_num; 389 unsigned int rate_den; 390 unsigned int no_period_wakeup: 1; 391 392 /* -- SW params; see struct snd_pcm_sw_params for comments -- */ 393 int tstamp_mode; 394 unsigned int period_step; 395 snd_pcm_uframes_t start_threshold; 396 snd_pcm_uframes_t stop_threshold; 397 snd_pcm_uframes_t silence_threshold; 398 snd_pcm_uframes_t silence_size; 399 snd_pcm_uframes_t boundary; 400 401 /* internal data of auto-silencer */ 402 snd_pcm_uframes_t silence_start; /* starting pointer to silence area */ 403 snd_pcm_uframes_t silence_filled; /* already filled part of silence area */ 404 405 bool std_sync_id; /* hardware synchronization - standard per card ID */ 406 407 /* -- mmap -- */ 408 struct snd_pcm_mmap_status *status; 409 struct snd_pcm_mmap_control *control; 410 411 /* -- locking / scheduling -- */ 412 snd_pcm_uframes_t twake; /* do transfer (!poll) wakeup if non-zero */ 413 wait_queue_head_t sleep; /* poll sleep */ 414 wait_queue_head_t tsleep; /* transfer sleep */ 415 struct snd_fasync *fasync; 416 bool stop_operating; /* sync_stop will be called */ 417 struct mutex buffer_mutex; /* protect for buffer changes */ 418 atomic_t buffer_accessing; /* >0: in r/w operation, <0: blocked */ 419 420 /* -- private section -- */ 421 void *private_data; 422 void (*private_free)(struct snd_pcm_runtime *runtime); 423 424 /* -- hardware description -- */ 425 struct snd_pcm_hardware hw; 426 struct snd_pcm_hw_constraints hw_constraints; 427 428 /* -- timer -- */ 429 unsigned int timer_resolution; /* timer resolution */ 430 int tstamp_type; /* timestamp type */ 431 432 /* -- DMA -- */ 433 unsigned char *dma_area; /* DMA area */ 434 dma_addr_t dma_addr; /* physical bus address (not accessible from main CPU) */ 435 size_t dma_bytes; /* size of DMA area */ 436 437 struct snd_dma_buffer *dma_buffer_p; /* allocated buffer */ 438 unsigned int buffer_changed:1; /* buffer allocation changed; set only in managed mode */ 439 440 /* -- audio timestamp config -- */ 441 struct snd_pcm_audio_tstamp_config audio_tstamp_config; 442 struct snd_pcm_audio_tstamp_report audio_tstamp_report; 443 struct timespec64 driver_tstamp; 444 445 #if IS_ENABLED(CONFIG_SND_PCM_OSS) 446 /* -- OSS things -- */ 447 struct snd_pcm_oss_runtime oss; 448 #endif 449 }; 450 451 struct snd_pcm_group { /* keep linked substreams */ 452 spinlock_t lock; 453 struct mutex mutex; 454 struct list_head substreams; 455 refcount_t refs; 456 }; 457 458 struct pid; 459 460 struct snd_pcm_substream { 461 struct snd_pcm *pcm; 462 struct snd_pcm_str *pstr; 463 void *private_data; /* copied from pcm->private_data */ 464 int number; 465 char name[32]; /* substream name */ 466 int stream; /* stream (direction) */ 467 struct pm_qos_request latency_pm_qos_req; /* pm_qos request */ 468 size_t buffer_bytes_max; /* limit ring buffer size */ 469 struct snd_dma_buffer dma_buffer; 470 size_t dma_max; 471 /* -- hardware operations -- */ 472 const struct snd_pcm_ops *ops; 473 /* -- runtime information -- */ 474 struct snd_pcm_runtime *runtime; 475 /* -- timer section -- */ 476 struct snd_timer *timer; /* timer */ 477 unsigned timer_running: 1; /* time is running */ 478 long wait_time; /* time in ms for R/W to wait for avail */ 479 /* -- next substream -- */ 480 struct snd_pcm_substream *next; 481 /* -- linked substreams -- */ 482 struct list_head link_list; /* linked list member */ 483 struct snd_pcm_group self_group; /* fake group for non linked substream (with substream lock inside) */ 484 struct snd_pcm_group *group; /* pointer to current group */ 485 /* -- assigned files -- */ 486 int ref_count; 487 atomic_t mmap_count; 488 unsigned int f_flags; 489 void (*pcm_release)(struct snd_pcm_substream *); 490 struct pid *pid; 491 #if IS_ENABLED(CONFIG_SND_PCM_OSS) 492 /* -- OSS things -- */ 493 struct snd_pcm_oss_substream oss; 494 #endif 495 #ifdef CONFIG_SND_VERBOSE_PROCFS 496 struct snd_info_entry *proc_root; 497 #endif /* CONFIG_SND_VERBOSE_PROCFS */ 498 /* misc flags */ 499 unsigned int hw_opened: 1; 500 unsigned int managed_buffer_alloc:1; 501 }; 502 503 #define SUBSTREAM_BUSY(substream) ((substream)->ref_count > 0) 504 505 506 struct snd_pcm_str { 507 int stream; /* stream (direction) */ 508 struct snd_pcm *pcm; 509 /* -- substreams -- */ 510 unsigned int substream_count; 511 unsigned int substream_opened; 512 struct snd_pcm_substream *substream; 513 #if IS_ENABLED(CONFIG_SND_PCM_OSS) 514 /* -- OSS things -- */ 515 struct snd_pcm_oss_stream oss; 516 #endif 517 #ifdef CONFIG_SND_VERBOSE_PROCFS 518 struct snd_info_entry *proc_root; 519 #ifdef CONFIG_SND_PCM_XRUN_DEBUG 520 unsigned int xrun_debug; /* 0 = disabled, 1 = verbose, 2 = stacktrace */ 521 #endif 522 #endif 523 struct snd_kcontrol *chmap_kctl; /* channel-mapping controls */ 524 struct device *dev; 525 }; 526 527 struct snd_pcm { 528 struct snd_card *card; 529 struct list_head list; 530 int device; /* device number */ 531 unsigned int info_flags; 532 unsigned short dev_class; 533 unsigned short dev_subclass; 534 char id[64]; 535 char name[80]; 536 struct snd_pcm_str streams[2]; 537 struct mutex open_mutex; 538 wait_queue_head_t open_wait; 539 void *private_data; 540 void (*private_free) (struct snd_pcm *pcm); 541 bool internal; /* pcm is for internal use only */ 542 bool nonatomic; /* whole PCM operations are in non-atomic context */ 543 bool no_device_suspend; /* don't invoke device PM suspend */ 544 #if IS_ENABLED(CONFIG_SND_PCM_OSS) 545 struct snd_pcm_oss oss; 546 #endif 547 }; 548 549 /* 550 * Registering 551 */ 552 553 extern const struct file_operations snd_pcm_f_ops[2]; 554 555 int snd_pcm_new(struct snd_card *card, const char *id, int device, 556 int playback_count, int capture_count, 557 struct snd_pcm **rpcm); 558 int snd_pcm_new_internal(struct snd_card *card, const char *id, int device, 559 int playback_count, int capture_count, 560 struct snd_pcm **rpcm); 561 int snd_pcm_new_stream(struct snd_pcm *pcm, int stream, int substream_count); 562 563 #if IS_ENABLED(CONFIG_SND_PCM_OSS) 564 struct snd_pcm_notify { 565 int (*n_register) (struct snd_pcm * pcm); 566 int (*n_disconnect) (struct snd_pcm * pcm); 567 int (*n_unregister) (struct snd_pcm * pcm); 568 struct list_head list; 569 }; 570 int snd_pcm_notify(struct snd_pcm_notify *notify, int nfree); 571 #endif 572 573 /* 574 * Native I/O 575 */ 576 577 int snd_pcm_info(struct snd_pcm_substream *substream, struct snd_pcm_info *info); 578 int snd_pcm_info_user(struct snd_pcm_substream *substream, 579 struct snd_pcm_info __user *info); 580 int snd_pcm_status64(struct snd_pcm_substream *substream, 581 struct snd_pcm_status64 *status); 582 int snd_pcm_start(struct snd_pcm_substream *substream); 583 int snd_pcm_stop(struct snd_pcm_substream *substream, snd_pcm_state_t status); 584 int snd_pcm_drain_done(struct snd_pcm_substream *substream); 585 int snd_pcm_stop_xrun(struct snd_pcm_substream *substream); 586 #ifdef CONFIG_PM 587 int snd_pcm_suspend_all(struct snd_pcm *pcm); 588 #else 589 static inline int snd_pcm_suspend_all(struct snd_pcm *pcm) 590 { 591 return 0; 592 } 593 #endif 594 int snd_pcm_kernel_ioctl(struct snd_pcm_substream *substream, unsigned int cmd, void *arg); 595 int snd_pcm_open_substream(struct snd_pcm *pcm, int stream, struct file *file, 596 struct snd_pcm_substream **rsubstream); 597 void snd_pcm_release_substream(struct snd_pcm_substream *substream); 598 int snd_pcm_attach_substream(struct snd_pcm *pcm, int stream, struct file *file, 599 struct snd_pcm_substream **rsubstream); 600 void snd_pcm_detach_substream(struct snd_pcm_substream *substream); 601 int snd_pcm_mmap_data(struct snd_pcm_substream *substream, struct file *file, struct vm_area_struct *area); 602 603 604 #ifdef CONFIG_SND_DEBUG 605 void snd_pcm_debug_name(struct snd_pcm_substream *substream, 606 char *name, size_t len); 607 #else 608 static inline void 609 snd_pcm_debug_name(struct snd_pcm_substream *substream, char *buf, size_t size) 610 { 611 *buf = 0; 612 } 613 #endif 614 615 /* 616 * PCM library 617 */ 618 619 /** 620 * snd_pcm_stream_linked - Check whether the substream is linked with others 621 * @substream: substream to check 622 * 623 * Return: true if the given substream is being linked with others 624 */ 625 static inline int snd_pcm_stream_linked(struct snd_pcm_substream *substream) 626 { 627 return substream->group != &substream->self_group; 628 } 629 630 void snd_pcm_stream_lock(struct snd_pcm_substream *substream); 631 void snd_pcm_stream_unlock(struct snd_pcm_substream *substream); 632 void snd_pcm_stream_lock_irq(struct snd_pcm_substream *substream); 633 void snd_pcm_stream_unlock_irq(struct snd_pcm_substream *substream); 634 unsigned long _snd_pcm_stream_lock_irqsave(struct snd_pcm_substream *substream); 635 unsigned long _snd_pcm_stream_lock_irqsave_nested(struct snd_pcm_substream *substream); 636 637 /** 638 * snd_pcm_stream_lock_irqsave - Lock the PCM stream 639 * @substream: PCM substream 640 * @flags: irq flags 641 * 642 * This locks the PCM stream like snd_pcm_stream_lock() but with the local 643 * IRQ (only when nonatomic is false). In nonatomic case, this is identical 644 * as snd_pcm_stream_lock(). 645 */ 646 #define snd_pcm_stream_lock_irqsave(substream, flags) \ 647 do { \ 648 typecheck(unsigned long, flags); \ 649 flags = _snd_pcm_stream_lock_irqsave(substream); \ 650 } while (0) 651 void snd_pcm_stream_unlock_irqrestore(struct snd_pcm_substream *substream, 652 unsigned long flags); 653 654 /** 655 * snd_pcm_stream_lock_irqsave_nested - Single-nested PCM stream locking 656 * @substream: PCM substream 657 * @flags: irq flags 658 * 659 * This locks the PCM stream like snd_pcm_stream_lock_irqsave() but with 660 * the single-depth lockdep subclass. 661 */ 662 #define snd_pcm_stream_lock_irqsave_nested(substream, flags) \ 663 do { \ 664 typecheck(unsigned long, flags); \ 665 flags = _snd_pcm_stream_lock_irqsave_nested(substream); \ 666 } while (0) 667 668 /* definitions for guard(); use like guard(pcm_stream_lock) */ 669 DEFINE_LOCK_GUARD_1(pcm_stream_lock, struct snd_pcm_substream, 670 snd_pcm_stream_lock(_T->lock), 671 snd_pcm_stream_unlock(_T->lock)) 672 DEFINE_LOCK_GUARD_1(pcm_stream_lock_irq, struct snd_pcm_substream, 673 snd_pcm_stream_lock_irq(_T->lock), 674 snd_pcm_stream_unlock_irq(_T->lock)) 675 DEFINE_LOCK_GUARD_1(pcm_stream_lock_irqsave, struct snd_pcm_substream, 676 snd_pcm_stream_lock_irqsave(_T->lock, _T->flags), 677 snd_pcm_stream_unlock_irqrestore(_T->lock, _T->flags), 678 unsigned long flags) 679 680 /** 681 * snd_pcm_group_for_each_entry - iterate over the linked substreams 682 * @s: the iterator 683 * @substream: the substream 684 * 685 * Iterate over the all linked substreams to the given @substream. 686 * When @substream isn't linked with any others, this gives returns @substream 687 * itself once. 688 */ 689 #define snd_pcm_group_for_each_entry(s, substream) \ 690 list_for_each_entry(s, &substream->group->substreams, link_list) 691 692 #define for_each_pcm_streams(stream) \ 693 for (stream = SNDRV_PCM_STREAM_PLAYBACK; \ 694 stream <= SNDRV_PCM_STREAM_LAST; \ 695 stream++) 696 697 /** 698 * snd_pcm_running - Check whether the substream is in a running state 699 * @substream: substream to check 700 * 701 * Return: true if the given substream is in the state RUNNING, or in the 702 * state DRAINING for playback. 703 */ 704 static inline int snd_pcm_running(struct snd_pcm_substream *substream) 705 { 706 return (substream->runtime->state == SNDRV_PCM_STATE_RUNNING || 707 (substream->runtime->state == SNDRV_PCM_STATE_DRAINING && 708 substream->stream == SNDRV_PCM_STREAM_PLAYBACK)); 709 } 710 711 /** 712 * __snd_pcm_set_state - Change the current PCM state 713 * @runtime: PCM runtime to set 714 * @state: the current state to set 715 * 716 * Call within the stream lock 717 */ 718 static inline void __snd_pcm_set_state(struct snd_pcm_runtime *runtime, 719 snd_pcm_state_t state) 720 { 721 runtime->state = state; 722 runtime->status->state = state; /* copy for mmap */ 723 } 724 725 /** 726 * bytes_to_samples - Unit conversion of the size from bytes to samples 727 * @runtime: PCM runtime instance 728 * @size: size in bytes 729 * 730 * Return: the size in samples 731 */ 732 static inline ssize_t bytes_to_samples(struct snd_pcm_runtime *runtime, ssize_t size) 733 { 734 return size * 8 / runtime->sample_bits; 735 } 736 737 /** 738 * bytes_to_frames - Unit conversion of the size from bytes to frames 739 * @runtime: PCM runtime instance 740 * @size: size in bytes 741 * 742 * Return: the size in frames 743 */ 744 static inline snd_pcm_sframes_t bytes_to_frames(struct snd_pcm_runtime *runtime, ssize_t size) 745 { 746 return size * 8 / runtime->frame_bits; 747 } 748 749 /** 750 * samples_to_bytes - Unit conversion of the size from samples to bytes 751 * @runtime: PCM runtime instance 752 * @size: size in samples 753 * 754 * Return: the byte size 755 */ 756 static inline ssize_t samples_to_bytes(struct snd_pcm_runtime *runtime, ssize_t size) 757 { 758 return size * runtime->sample_bits / 8; 759 } 760 761 /** 762 * frames_to_bytes - Unit conversion of the size from frames to bytes 763 * @runtime: PCM runtime instance 764 * @size: size in frames 765 * 766 * Return: the byte size 767 */ 768 static inline ssize_t frames_to_bytes(struct snd_pcm_runtime *runtime, snd_pcm_sframes_t size) 769 { 770 return size * runtime->frame_bits / 8; 771 } 772 773 /** 774 * frame_aligned - Check whether the byte size is aligned to frames 775 * @runtime: PCM runtime instance 776 * @bytes: size in bytes 777 * 778 * Return: true if aligned, or false if not 779 */ 780 static inline int frame_aligned(struct snd_pcm_runtime *runtime, ssize_t bytes) 781 { 782 return bytes % runtime->byte_align == 0; 783 } 784 785 /** 786 * snd_pcm_lib_buffer_bytes - Get the buffer size of the current PCM in bytes 787 * @substream: PCM substream 788 * 789 * Return: buffer byte size 790 */ 791 static inline size_t snd_pcm_lib_buffer_bytes(struct snd_pcm_substream *substream) 792 { 793 struct snd_pcm_runtime *runtime = substream->runtime; 794 return frames_to_bytes(runtime, runtime->buffer_size); 795 } 796 797 /** 798 * snd_pcm_lib_period_bytes - Get the period size of the current PCM in bytes 799 * @substream: PCM substream 800 * 801 * Return: period byte size 802 */ 803 static inline size_t snd_pcm_lib_period_bytes(struct snd_pcm_substream *substream) 804 { 805 struct snd_pcm_runtime *runtime = substream->runtime; 806 return frames_to_bytes(runtime, runtime->period_size); 807 } 808 809 /** 810 * snd_pcm_playback_avail - Get the available (writable) space for playback 811 * @runtime: PCM runtime instance 812 * 813 * Result is between 0 ... (boundary - 1) 814 * 815 * Return: available frame size 816 */ 817 static inline snd_pcm_uframes_t snd_pcm_playback_avail(struct snd_pcm_runtime *runtime) 818 { 819 snd_pcm_sframes_t avail = runtime->status->hw_ptr + runtime->buffer_size - runtime->control->appl_ptr; 820 if (avail < 0) 821 avail += runtime->boundary; 822 else if ((snd_pcm_uframes_t) avail >= runtime->boundary) 823 avail -= runtime->boundary; 824 return avail; 825 } 826 827 /** 828 * snd_pcm_capture_avail - Get the available (readable) space for capture 829 * @runtime: PCM runtime instance 830 * 831 * Result is between 0 ... (boundary - 1) 832 * 833 * Return: available frame size 834 */ 835 static inline snd_pcm_uframes_t snd_pcm_capture_avail(struct snd_pcm_runtime *runtime) 836 { 837 snd_pcm_sframes_t avail = runtime->status->hw_ptr - runtime->control->appl_ptr; 838 if (avail < 0) 839 avail += runtime->boundary; 840 return avail; 841 } 842 843 /** 844 * snd_pcm_playback_hw_avail - Get the queued space for playback 845 * @runtime: PCM runtime instance 846 * 847 * Return: available frame size 848 */ 849 static inline snd_pcm_sframes_t snd_pcm_playback_hw_avail(struct snd_pcm_runtime *runtime) 850 { 851 return runtime->buffer_size - snd_pcm_playback_avail(runtime); 852 } 853 854 /** 855 * snd_pcm_capture_hw_avail - Get the free space for capture 856 * @runtime: PCM runtime instance 857 * 858 * Return: available frame size 859 */ 860 static inline snd_pcm_sframes_t snd_pcm_capture_hw_avail(struct snd_pcm_runtime *runtime) 861 { 862 return runtime->buffer_size - snd_pcm_capture_avail(runtime); 863 } 864 865 /** 866 * snd_pcm_playback_ready - check whether the playback buffer is available 867 * @substream: the pcm substream instance 868 * 869 * Checks whether enough free space is available on the playback buffer. 870 * 871 * Return: Non-zero if available, or zero if not. 872 */ 873 static inline int snd_pcm_playback_ready(struct snd_pcm_substream *substream) 874 { 875 struct snd_pcm_runtime *runtime = substream->runtime; 876 return snd_pcm_playback_avail(runtime) >= runtime->control->avail_min; 877 } 878 879 /** 880 * snd_pcm_capture_ready - check whether the capture buffer is available 881 * @substream: the pcm substream instance 882 * 883 * Checks whether enough capture data is available on the capture buffer. 884 * 885 * Return: Non-zero if available, or zero if not. 886 */ 887 static inline int snd_pcm_capture_ready(struct snd_pcm_substream *substream) 888 { 889 struct snd_pcm_runtime *runtime = substream->runtime; 890 return snd_pcm_capture_avail(runtime) >= runtime->control->avail_min; 891 } 892 893 /** 894 * snd_pcm_playback_data - check whether any data exists on the playback buffer 895 * @substream: the pcm substream instance 896 * 897 * Checks whether any data exists on the playback buffer. 898 * 899 * Return: Non-zero if any data exists, or zero if not. If stop_threshold 900 * is bigger or equal to boundary, then this function returns always non-zero. 901 */ 902 static inline int snd_pcm_playback_data(struct snd_pcm_substream *substream) 903 { 904 struct snd_pcm_runtime *runtime = substream->runtime; 905 906 if (runtime->stop_threshold >= runtime->boundary) 907 return 1; 908 return snd_pcm_playback_avail(runtime) < runtime->buffer_size; 909 } 910 911 /** 912 * snd_pcm_playback_empty - check whether the playback buffer is empty 913 * @substream: the pcm substream instance 914 * 915 * Checks whether the playback buffer is empty. 916 * 917 * Return: Non-zero if empty, or zero if not. 918 */ 919 static inline int snd_pcm_playback_empty(struct snd_pcm_substream *substream) 920 { 921 struct snd_pcm_runtime *runtime = substream->runtime; 922 return snd_pcm_playback_avail(runtime) >= runtime->buffer_size; 923 } 924 925 /** 926 * snd_pcm_capture_empty - check whether the capture buffer is empty 927 * @substream: the pcm substream instance 928 * 929 * Checks whether the capture buffer is empty. 930 * 931 * Return: Non-zero if empty, or zero if not. 932 */ 933 static inline int snd_pcm_capture_empty(struct snd_pcm_substream *substream) 934 { 935 struct snd_pcm_runtime *runtime = substream->runtime; 936 return snd_pcm_capture_avail(runtime) == 0; 937 } 938 939 /** 940 * snd_pcm_trigger_done - Mark the master substream 941 * @substream: the pcm substream instance 942 * @master: the linked master substream 943 * 944 * When multiple substreams of the same card are linked and the hardware 945 * supports the single-shot operation, the driver calls this in the loop 946 * in snd_pcm_group_for_each_entry() for marking the substream as "done". 947 * Then most of trigger operations are performed only to the given master 948 * substream. 949 * 950 * The trigger_master mark is cleared at timestamp updates at the end 951 * of trigger operations. 952 */ 953 static inline void snd_pcm_trigger_done(struct snd_pcm_substream *substream, 954 struct snd_pcm_substream *master) 955 { 956 substream->runtime->trigger_master = master; 957 } 958 959 static inline int hw_is_mask(int var) 960 { 961 return var >= SNDRV_PCM_HW_PARAM_FIRST_MASK && 962 var <= SNDRV_PCM_HW_PARAM_LAST_MASK; 963 } 964 965 static inline int hw_is_interval(int var) 966 { 967 return var >= SNDRV_PCM_HW_PARAM_FIRST_INTERVAL && 968 var <= SNDRV_PCM_HW_PARAM_LAST_INTERVAL; 969 } 970 971 static inline struct snd_mask *hw_param_mask(struct snd_pcm_hw_params *params, 972 snd_pcm_hw_param_t var) 973 { 974 return ¶ms->masks[var - SNDRV_PCM_HW_PARAM_FIRST_MASK]; 975 } 976 977 static inline struct snd_interval *hw_param_interval(struct snd_pcm_hw_params *params, 978 snd_pcm_hw_param_t var) 979 { 980 return ¶ms->intervals[var - SNDRV_PCM_HW_PARAM_FIRST_INTERVAL]; 981 } 982 983 static inline const struct snd_mask *hw_param_mask_c(const struct snd_pcm_hw_params *params, 984 snd_pcm_hw_param_t var) 985 { 986 return ¶ms->masks[var - SNDRV_PCM_HW_PARAM_FIRST_MASK]; 987 } 988 989 static inline const struct snd_interval *hw_param_interval_c(const struct snd_pcm_hw_params *params, 990 snd_pcm_hw_param_t var) 991 { 992 return ¶ms->intervals[var - SNDRV_PCM_HW_PARAM_FIRST_INTERVAL]; 993 } 994 995 /** 996 * params_channels - Get the number of channels from the hw params 997 * @p: hw params 998 * 999 * Return: the number of channels 1000 */ 1001 static inline unsigned int params_channels(const struct snd_pcm_hw_params *p) 1002 { 1003 return hw_param_interval_c(p, SNDRV_PCM_HW_PARAM_CHANNELS)->min; 1004 } 1005 1006 /** 1007 * params_rate - Get the sample rate from the hw params 1008 * @p: hw params 1009 * 1010 * Return: the sample rate 1011 */ 1012 static inline unsigned int params_rate(const struct snd_pcm_hw_params *p) 1013 { 1014 return hw_param_interval_c(p, SNDRV_PCM_HW_PARAM_RATE)->min; 1015 } 1016 1017 /** 1018 * params_period_size - Get the period size (in frames) from the hw params 1019 * @p: hw params 1020 * 1021 * Return: the period size in frames 1022 */ 1023 static inline unsigned int params_period_size(const struct snd_pcm_hw_params *p) 1024 { 1025 return hw_param_interval_c(p, SNDRV_PCM_HW_PARAM_PERIOD_SIZE)->min; 1026 } 1027 1028 /** 1029 * params_periods - Get the number of periods from the hw params 1030 * @p: hw params 1031 * 1032 * Return: the number of periods 1033 */ 1034 static inline unsigned int params_periods(const struct snd_pcm_hw_params *p) 1035 { 1036 return hw_param_interval_c(p, SNDRV_PCM_HW_PARAM_PERIODS)->min; 1037 } 1038 1039 /** 1040 * params_buffer_size - Get the buffer size (in frames) from the hw params 1041 * @p: hw params 1042 * 1043 * Return: the buffer size in frames 1044 */ 1045 static inline unsigned int params_buffer_size(const struct snd_pcm_hw_params *p) 1046 { 1047 return hw_param_interval_c(p, SNDRV_PCM_HW_PARAM_BUFFER_SIZE)->min; 1048 } 1049 1050 /** 1051 * params_buffer_bytes - Get the buffer size (in bytes) from the hw params 1052 * @p: hw params 1053 * 1054 * Return: the buffer size in bytes 1055 */ 1056 static inline unsigned int params_buffer_bytes(const struct snd_pcm_hw_params *p) 1057 { 1058 return hw_param_interval_c(p, SNDRV_PCM_HW_PARAM_BUFFER_BYTES)->min; 1059 } 1060 1061 int snd_interval_refine(struct snd_interval *i, const struct snd_interval *v); 1062 int snd_interval_list(struct snd_interval *i, unsigned int count, 1063 const unsigned int *list, unsigned int mask); 1064 int snd_interval_ranges(struct snd_interval *i, unsigned int count, 1065 const struct snd_interval *list, unsigned int mask); 1066 int snd_interval_ratnum(struct snd_interval *i, 1067 unsigned int rats_count, const struct snd_ratnum *rats, 1068 unsigned int *nump, unsigned int *denp); 1069 1070 void _snd_pcm_hw_params_any(struct snd_pcm_hw_params *params); 1071 void _snd_pcm_hw_param_setempty(struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var); 1072 1073 int snd_pcm_hw_refine(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params); 1074 1075 int snd_pcm_hw_constraint_mask64(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var, 1076 u_int64_t mask); 1077 int snd_pcm_hw_constraint_minmax(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var, 1078 unsigned int min, unsigned int max); 1079 int snd_pcm_hw_constraint_integer(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var); 1080 int snd_pcm_hw_constraint_list(struct snd_pcm_runtime *runtime, 1081 unsigned int cond, 1082 snd_pcm_hw_param_t var, 1083 const struct snd_pcm_hw_constraint_list *l); 1084 int snd_pcm_hw_constraint_ranges(struct snd_pcm_runtime *runtime, 1085 unsigned int cond, 1086 snd_pcm_hw_param_t var, 1087 const struct snd_pcm_hw_constraint_ranges *r); 1088 int snd_pcm_hw_constraint_ratnums(struct snd_pcm_runtime *runtime, 1089 unsigned int cond, 1090 snd_pcm_hw_param_t var, 1091 const struct snd_pcm_hw_constraint_ratnums *r); 1092 int snd_pcm_hw_constraint_ratdens(struct snd_pcm_runtime *runtime, 1093 unsigned int cond, 1094 snd_pcm_hw_param_t var, 1095 const struct snd_pcm_hw_constraint_ratdens *r); 1096 int snd_pcm_hw_constraint_msbits(struct snd_pcm_runtime *runtime, 1097 unsigned int cond, 1098 unsigned int width, 1099 unsigned int msbits); 1100 int snd_pcm_hw_constraint_step(struct snd_pcm_runtime *runtime, 1101 unsigned int cond, 1102 snd_pcm_hw_param_t var, 1103 unsigned long step); 1104 int snd_pcm_hw_constraint_pow2(struct snd_pcm_runtime *runtime, 1105 unsigned int cond, 1106 snd_pcm_hw_param_t var); 1107 int snd_pcm_hw_rule_noresample(struct snd_pcm_runtime *runtime, 1108 unsigned int base_rate); 1109 int snd_pcm_hw_rule_add(struct snd_pcm_runtime *runtime, 1110 unsigned int cond, 1111 int var, 1112 snd_pcm_hw_rule_func_t func, void *private, 1113 int dep, ...); 1114 1115 /** 1116 * snd_pcm_hw_constraint_single() - Constrain parameter to a single value 1117 * @runtime: PCM runtime instance 1118 * @var: The hw_params variable to constrain 1119 * @val: The value to constrain to 1120 * 1121 * Return: Positive if the value is changed, zero if it's not changed, or a 1122 * negative error code. 1123 */ 1124 static inline int snd_pcm_hw_constraint_single( 1125 struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var, 1126 unsigned int val) 1127 { 1128 return snd_pcm_hw_constraint_minmax(runtime, var, val, val); 1129 } 1130 1131 int snd_pcm_format_signed(snd_pcm_format_t format); 1132 int snd_pcm_format_unsigned(snd_pcm_format_t format); 1133 int snd_pcm_format_linear(snd_pcm_format_t format); 1134 int snd_pcm_format_little_endian(snd_pcm_format_t format); 1135 int snd_pcm_format_big_endian(snd_pcm_format_t format); 1136 #if 0 /* just for kernel-doc */ 1137 /** 1138 * snd_pcm_format_cpu_endian - Check the PCM format is CPU-endian 1139 * @format: the format to check 1140 * 1141 * Return: 1 if the given PCM format is CPU-endian, 0 if 1142 * opposite, or a negative error code if endian not specified. 1143 */ 1144 int snd_pcm_format_cpu_endian(snd_pcm_format_t format); 1145 #endif /* DocBook */ 1146 #ifdef SNDRV_LITTLE_ENDIAN 1147 #define snd_pcm_format_cpu_endian(format) snd_pcm_format_little_endian(format) 1148 #else 1149 #define snd_pcm_format_cpu_endian(format) snd_pcm_format_big_endian(format) 1150 #endif 1151 int snd_pcm_format_width(snd_pcm_format_t format); /* in bits */ 1152 int snd_pcm_format_physical_width(snd_pcm_format_t format); /* in bits */ 1153 ssize_t snd_pcm_format_size(snd_pcm_format_t format, size_t samples); 1154 const unsigned char *snd_pcm_format_silence_64(snd_pcm_format_t format); 1155 int snd_pcm_format_set_silence(snd_pcm_format_t format, void *buf, unsigned int frames); 1156 1157 void snd_pcm_set_ops(struct snd_pcm * pcm, int direction, 1158 const struct snd_pcm_ops *ops); 1159 void snd_pcm_set_sync_per_card(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params, 1160 const unsigned char *id, unsigned int len); 1161 /** 1162 * snd_pcm_set_sync - set the PCM sync id 1163 * @substream: the pcm substream 1164 * 1165 * Use the default PCM sync identifier for the specific card. 1166 */ 1167 static inline void snd_pcm_set_sync(struct snd_pcm_substream *substream) 1168 { 1169 substream->runtime->std_sync_id = true; 1170 } 1171 int snd_pcm_lib_ioctl(struct snd_pcm_substream *substream, 1172 unsigned int cmd, void *arg); 1173 void snd_pcm_period_elapsed_under_stream_lock(struct snd_pcm_substream *substream); 1174 void snd_pcm_period_elapsed(struct snd_pcm_substream *substream); 1175 snd_pcm_sframes_t __snd_pcm_lib_xfer(struct snd_pcm_substream *substream, 1176 void *buf, bool interleaved, 1177 snd_pcm_uframes_t frames, bool in_kernel); 1178 1179 static inline snd_pcm_sframes_t 1180 snd_pcm_lib_write(struct snd_pcm_substream *substream, 1181 const void __user *buf, snd_pcm_uframes_t frames) 1182 { 1183 return __snd_pcm_lib_xfer(substream, (void __force *)buf, true, frames, false); 1184 } 1185 1186 static inline snd_pcm_sframes_t 1187 snd_pcm_lib_read(struct snd_pcm_substream *substream, 1188 void __user *buf, snd_pcm_uframes_t frames) 1189 { 1190 return __snd_pcm_lib_xfer(substream, (void __force *)buf, true, frames, false); 1191 } 1192 1193 static inline snd_pcm_sframes_t 1194 snd_pcm_lib_writev(struct snd_pcm_substream *substream, 1195 void __user **bufs, snd_pcm_uframes_t frames) 1196 { 1197 return __snd_pcm_lib_xfer(substream, (void *)bufs, false, frames, false); 1198 } 1199 1200 static inline snd_pcm_sframes_t 1201 snd_pcm_lib_readv(struct snd_pcm_substream *substream, 1202 void __user **bufs, snd_pcm_uframes_t frames) 1203 { 1204 return __snd_pcm_lib_xfer(substream, (void *)bufs, false, frames, false); 1205 } 1206 1207 static inline snd_pcm_sframes_t 1208 snd_pcm_kernel_write(struct snd_pcm_substream *substream, 1209 const void *buf, snd_pcm_uframes_t frames) 1210 { 1211 return __snd_pcm_lib_xfer(substream, (void *)buf, true, frames, true); 1212 } 1213 1214 static inline snd_pcm_sframes_t 1215 snd_pcm_kernel_read(struct snd_pcm_substream *substream, 1216 void *buf, snd_pcm_uframes_t frames) 1217 { 1218 return __snd_pcm_lib_xfer(substream, buf, true, frames, true); 1219 } 1220 1221 static inline snd_pcm_sframes_t 1222 snd_pcm_kernel_writev(struct snd_pcm_substream *substream, 1223 void **bufs, snd_pcm_uframes_t frames) 1224 { 1225 return __snd_pcm_lib_xfer(substream, bufs, false, frames, true); 1226 } 1227 1228 static inline snd_pcm_sframes_t 1229 snd_pcm_kernel_readv(struct snd_pcm_substream *substream, 1230 void **bufs, snd_pcm_uframes_t frames) 1231 { 1232 return __snd_pcm_lib_xfer(substream, bufs, false, frames, true); 1233 } 1234 1235 int snd_pcm_hw_limit_rates(struct snd_pcm_hardware *hw); 1236 1237 static inline int 1238 snd_pcm_limit_hw_rates(struct snd_pcm_runtime *runtime) 1239 { 1240 return snd_pcm_hw_limit_rates(&runtime->hw); 1241 } 1242 1243 unsigned int snd_pcm_rate_to_rate_bit(unsigned int rate); 1244 unsigned int snd_pcm_rate_bit_to_rate(unsigned int rate_bit); 1245 unsigned int snd_pcm_rate_mask_intersect(unsigned int rates_a, 1246 unsigned int rates_b); 1247 unsigned int snd_pcm_rate_range_to_bits(unsigned int rate_min, 1248 unsigned int rate_max); 1249 1250 /** 1251 * snd_pcm_set_runtime_buffer - Set the PCM runtime buffer 1252 * @substream: PCM substream to set 1253 * @bufp: the buffer information, NULL to clear 1254 * 1255 * Copy the buffer information to runtime->dma_buffer when @bufp is non-NULL. 1256 * Otherwise it clears the current buffer information. 1257 */ 1258 static inline void snd_pcm_set_runtime_buffer(struct snd_pcm_substream *substream, 1259 struct snd_dma_buffer *bufp) 1260 { 1261 struct snd_pcm_runtime *runtime = substream->runtime; 1262 if (bufp) { 1263 runtime->dma_buffer_p = bufp; 1264 runtime->dma_area = bufp->area; 1265 runtime->dma_addr = bufp->addr; 1266 runtime->dma_bytes = bufp->bytes; 1267 } else { 1268 runtime->dma_buffer_p = NULL; 1269 runtime->dma_area = NULL; 1270 runtime->dma_addr = 0; 1271 runtime->dma_bytes = 0; 1272 } 1273 } 1274 1275 /** 1276 * snd_pcm_gettime - Fill the timespec64 depending on the timestamp mode 1277 * @runtime: PCM runtime instance 1278 * @tv: timespec64 to fill 1279 */ 1280 static inline void snd_pcm_gettime(struct snd_pcm_runtime *runtime, 1281 struct timespec64 *tv) 1282 { 1283 switch (runtime->tstamp_type) { 1284 case SNDRV_PCM_TSTAMP_TYPE_MONOTONIC: 1285 ktime_get_ts64(tv); 1286 break; 1287 case SNDRV_PCM_TSTAMP_TYPE_MONOTONIC_RAW: 1288 ktime_get_raw_ts64(tv); 1289 break; 1290 default: 1291 ktime_get_real_ts64(tv); 1292 break; 1293 } 1294 } 1295 1296 /* 1297 * Memory 1298 */ 1299 1300 void snd_pcm_lib_preallocate_free(struct snd_pcm_substream *substream); 1301 void snd_pcm_lib_preallocate_free_for_all(struct snd_pcm *pcm); 1302 void snd_pcm_lib_preallocate_pages(struct snd_pcm_substream *substream, 1303 int type, struct device *data, 1304 size_t size, size_t max); 1305 void snd_pcm_lib_preallocate_pages_for_all(struct snd_pcm *pcm, 1306 int type, void *data, 1307 size_t size, size_t max); 1308 int snd_pcm_lib_malloc_pages(struct snd_pcm_substream *substream, size_t size); 1309 int snd_pcm_lib_free_pages(struct snd_pcm_substream *substream); 1310 1311 int snd_pcm_set_managed_buffer(struct snd_pcm_substream *substream, int type, 1312 struct device *data, size_t size, size_t max); 1313 int snd_pcm_set_managed_buffer_all(struct snd_pcm *pcm, int type, 1314 struct device *data, 1315 size_t size, size_t max); 1316 1317 /** 1318 * snd_pcm_set_fixed_buffer - Preallocate and set up the fixed size PCM buffer 1319 * @substream: the pcm substream instance 1320 * @type: DMA type (SNDRV_DMA_TYPE_*) 1321 * @data: DMA type dependent data 1322 * @size: the requested pre-allocation size in bytes 1323 * 1324 * This is a variant of snd_pcm_set_managed_buffer(), but this pre-allocates 1325 * only the given sized buffer and doesn't allow re-allocation nor dynamic 1326 * allocation of a larger buffer unlike the standard one. 1327 * The function may return -ENOMEM error, hence the caller must check it. 1328 * 1329 * Return: zero if successful, or a negative error code 1330 */ 1331 static inline int __must_check 1332 snd_pcm_set_fixed_buffer(struct snd_pcm_substream *substream, int type, 1333 struct device *data, size_t size) 1334 { 1335 return snd_pcm_set_managed_buffer(substream, type, data, size, 0); 1336 } 1337 1338 /** 1339 * snd_pcm_set_fixed_buffer_all - Preallocate and set up the fixed size PCM buffer 1340 * @pcm: the pcm instance 1341 * @type: DMA type (SNDRV_DMA_TYPE_*) 1342 * @data: DMA type dependent data 1343 * @size: the requested pre-allocation size in bytes 1344 * 1345 * Apply the set up of the fixed buffer via snd_pcm_set_fixed_buffer() for 1346 * all substream. If any of allocation fails, it returns -ENOMEM, hence the 1347 * caller must check the return value. 1348 * 1349 * Return: zero if successful, or a negative error code 1350 */ 1351 static inline int __must_check 1352 snd_pcm_set_fixed_buffer_all(struct snd_pcm *pcm, int type, 1353 struct device *data, size_t size) 1354 { 1355 return snd_pcm_set_managed_buffer_all(pcm, type, data, size, 0); 1356 } 1357 1358 int _snd_pcm_lib_alloc_vmalloc_buffer(struct snd_pcm_substream *substream, 1359 size_t size, gfp_t gfp_flags); 1360 int snd_pcm_lib_free_vmalloc_buffer(struct snd_pcm_substream *substream); 1361 struct page *snd_pcm_lib_get_vmalloc_page(struct snd_pcm_substream *substream, 1362 unsigned long offset); 1363 /** 1364 * snd_pcm_lib_alloc_vmalloc_buffer - allocate virtual DMA buffer 1365 * @substream: the substream to allocate the buffer to 1366 * @size: the requested buffer size, in bytes 1367 * 1368 * Allocates the PCM substream buffer using vmalloc(), i.e., the memory is 1369 * contiguous in kernel virtual space, but not in physical memory. Use this 1370 * if the buffer is accessed by kernel code but not by device DMA. 1371 * 1372 * Return: 1 if the buffer was changed, 0 if not changed, or a negative error 1373 * code. 1374 */ 1375 static inline int snd_pcm_lib_alloc_vmalloc_buffer 1376 (struct snd_pcm_substream *substream, size_t size) 1377 { 1378 return _snd_pcm_lib_alloc_vmalloc_buffer(substream, size, 1379 GFP_KERNEL | __GFP_HIGHMEM | __GFP_ZERO); 1380 } 1381 1382 /** 1383 * snd_pcm_lib_alloc_vmalloc_32_buffer - allocate 32-bit-addressable buffer 1384 * @substream: the substream to allocate the buffer to 1385 * @size: the requested buffer size, in bytes 1386 * 1387 * This function works like snd_pcm_lib_alloc_vmalloc_buffer(), but uses 1388 * vmalloc_32(), i.e., the pages are allocated from 32-bit-addressable memory. 1389 * 1390 * Return: 1 if the buffer was changed, 0 if not changed, or a negative error 1391 * code. 1392 */ 1393 static inline int snd_pcm_lib_alloc_vmalloc_32_buffer 1394 (struct snd_pcm_substream *substream, size_t size) 1395 { 1396 return _snd_pcm_lib_alloc_vmalloc_buffer(substream, size, 1397 GFP_KERNEL | GFP_DMA32 | __GFP_ZERO); 1398 } 1399 1400 #define snd_pcm_get_dma_buf(substream) ((substream)->runtime->dma_buffer_p) 1401 1402 /** 1403 * snd_pcm_sgbuf_get_addr - Get the DMA address at the corresponding offset 1404 * @substream: PCM substream 1405 * @ofs: byte offset 1406 * 1407 * Return: DMA address 1408 */ 1409 static inline dma_addr_t 1410 snd_pcm_sgbuf_get_addr(struct snd_pcm_substream *substream, unsigned int ofs) 1411 { 1412 return snd_sgbuf_get_addr(snd_pcm_get_dma_buf(substream), ofs); 1413 } 1414 1415 /** 1416 * snd_pcm_sgbuf_get_chunk_size - Compute the max size that fits within the 1417 * contig. page from the given size 1418 * @substream: PCM substream 1419 * @ofs: byte offset 1420 * @size: byte size to examine 1421 * 1422 * Return: chunk size 1423 */ 1424 static inline unsigned int 1425 snd_pcm_sgbuf_get_chunk_size(struct snd_pcm_substream *substream, 1426 unsigned int ofs, unsigned int size) 1427 { 1428 return snd_sgbuf_get_chunk_size(snd_pcm_get_dma_buf(substream), ofs, size); 1429 } 1430 1431 /** 1432 * snd_pcm_mmap_data_open - increase the mmap counter 1433 * @area: VMA 1434 * 1435 * PCM mmap callback should handle this counter properly 1436 */ 1437 static inline void snd_pcm_mmap_data_open(struct vm_area_struct *area) 1438 { 1439 struct snd_pcm_substream *substream = (struct snd_pcm_substream *)area->vm_private_data; 1440 atomic_inc(&substream->mmap_count); 1441 } 1442 1443 /** 1444 * snd_pcm_mmap_data_close - decrease the mmap counter 1445 * @area: VMA 1446 * 1447 * PCM mmap callback should handle this counter properly 1448 */ 1449 static inline void snd_pcm_mmap_data_close(struct vm_area_struct *area) 1450 { 1451 struct snd_pcm_substream *substream = (struct snd_pcm_substream *)area->vm_private_data; 1452 atomic_dec(&substream->mmap_count); 1453 } 1454 1455 int snd_pcm_lib_default_mmap(struct snd_pcm_substream *substream, 1456 struct vm_area_struct *area); 1457 /* mmap for io-memory area */ 1458 #if defined(CONFIG_X86) || defined(CONFIG_PPC) || defined(CONFIG_ALPHA) 1459 #define SNDRV_PCM_INFO_MMAP_IOMEM SNDRV_PCM_INFO_MMAP 1460 int snd_pcm_lib_mmap_iomem(struct snd_pcm_substream *substream, struct vm_area_struct *area); 1461 #else 1462 #define SNDRV_PCM_INFO_MMAP_IOMEM 0 1463 #define snd_pcm_lib_mmap_iomem NULL 1464 #endif 1465 1466 /** 1467 * snd_pcm_limit_isa_dma_size - Get the max size fitting with ISA DMA transfer 1468 * @dma: DMA number 1469 * @max: pointer to store the max size 1470 */ 1471 static inline void snd_pcm_limit_isa_dma_size(int dma, size_t *max) 1472 { 1473 *max = dma < 4 ? 64 * 1024 : 128 * 1024; 1474 } 1475 1476 /* 1477 * Misc 1478 */ 1479 1480 #define SNDRV_PCM_DEFAULT_CON_SPDIF (IEC958_AES0_CON_EMPHASIS_NONE|\ 1481 (IEC958_AES1_CON_ORIGINAL<<8)|\ 1482 (IEC958_AES1_CON_PCM_CODER<<8)|\ 1483 (IEC958_AES3_CON_FS_48000<<24)) 1484 1485 const char *snd_pcm_format_name(snd_pcm_format_t format); 1486 1487 /** 1488 * snd_pcm_direction_name - Get a string naming the direction of a stream 1489 * @direction: Stream's direction, one of SNDRV_PCM_STREAM_XXX 1490 * 1491 * Returns a string naming the direction of the stream. 1492 */ 1493 static inline const char *snd_pcm_direction_name(int direction) 1494 { 1495 if (direction == SNDRV_PCM_STREAM_PLAYBACK) 1496 return "Playback"; 1497 else 1498 return "Capture"; 1499 } 1500 1501 /** 1502 * snd_pcm_stream_str - Get a string naming the direction of a stream 1503 * @substream: the pcm substream instance 1504 * 1505 * Return: A string naming the direction of the stream. 1506 */ 1507 static inline const char *snd_pcm_stream_str(struct snd_pcm_substream *substream) 1508 { 1509 return snd_pcm_direction_name(substream->stream); 1510 } 1511 1512 /* 1513 * PCM channel-mapping control API 1514 */ 1515 /* array element of channel maps */ 1516 struct snd_pcm_chmap_elem { 1517 unsigned char channels; 1518 unsigned char map[15]; 1519 }; 1520 1521 /* channel map information; retrieved via snd_kcontrol_chip() */ 1522 struct snd_pcm_chmap { 1523 struct snd_pcm *pcm; /* assigned PCM instance */ 1524 int stream; /* PLAYBACK or CAPTURE */ 1525 struct snd_kcontrol *kctl; 1526 const struct snd_pcm_chmap_elem *chmap; 1527 unsigned int max_channels; 1528 unsigned int channel_mask; /* optional: active channels bitmask */ 1529 void *private_data; /* optional: private data pointer */ 1530 }; 1531 1532 /** 1533 * snd_pcm_chmap_substream - get the PCM substream assigned to the given chmap info 1534 * @info: chmap information 1535 * @idx: the substream number index 1536 * 1537 * Return: the matched PCM substream, or NULL if not found 1538 */ 1539 static inline struct snd_pcm_substream * 1540 snd_pcm_chmap_substream(struct snd_pcm_chmap *info, unsigned int idx) 1541 { 1542 struct snd_pcm_substream *s; 1543 for (s = info->pcm->streams[info->stream].substream; s; s = s->next) 1544 if (s->number == idx) 1545 return s; 1546 return NULL; 1547 } 1548 1549 /* ALSA-standard channel maps (RL/RR prior to C/LFE) */ 1550 extern const struct snd_pcm_chmap_elem snd_pcm_std_chmaps[]; 1551 /* Other world's standard channel maps (C/LFE prior to RL/RR) */ 1552 extern const struct snd_pcm_chmap_elem snd_pcm_alt_chmaps[]; 1553 1554 /* bit masks to be passed to snd_pcm_chmap.channel_mask field */ 1555 #define SND_PCM_CHMAP_MASK_24 ((1U << 2) | (1U << 4)) 1556 #define SND_PCM_CHMAP_MASK_246 (SND_PCM_CHMAP_MASK_24 | (1U << 6)) 1557 #define SND_PCM_CHMAP_MASK_2468 (SND_PCM_CHMAP_MASK_246 | (1U << 8)) 1558 1559 int snd_pcm_add_chmap_ctls(struct snd_pcm *pcm, int stream, 1560 const struct snd_pcm_chmap_elem *chmap, 1561 int max_channels, 1562 unsigned long private_value, 1563 struct snd_pcm_chmap **info_ret); 1564 1565 /** 1566 * pcm_format_to_bits - Strong-typed conversion of pcm_format to bitwise 1567 * @pcm_format: PCM format 1568 * 1569 * Return: 64bit mask corresponding to the given PCM format 1570 */ 1571 static inline u64 pcm_format_to_bits(snd_pcm_format_t pcm_format) 1572 { 1573 return 1ULL << (__force int) pcm_format; 1574 } 1575 1576 /** 1577 * pcm_for_each_format - helper to iterate for each format type 1578 * @f: the iterator variable in snd_pcm_format_t type 1579 */ 1580 #define pcm_for_each_format(f) \ 1581 for ((f) = SNDRV_PCM_FORMAT_FIRST; \ 1582 (__force int)(f) <= (__force int)SNDRV_PCM_FORMAT_LAST; \ 1583 (f) = (__force snd_pcm_format_t)((__force int)(f) + 1)) 1584 1585 /* printk helpers */ 1586 #define pcm_err(pcm, fmt, args...) \ 1587 dev_err((pcm)->card->dev, fmt, ##args) 1588 #define pcm_warn(pcm, fmt, args...) \ 1589 dev_warn((pcm)->card->dev, fmt, ##args) 1590 #define pcm_dbg(pcm, fmt, args...) \ 1591 dev_dbg((pcm)->card->dev, fmt, ##args) 1592 1593 /* helpers for copying between iov_iter and iomem */ 1594 int copy_to_iter_fromio(struct iov_iter *itert, const void __iomem *src, 1595 size_t count); 1596 int copy_from_iter_toio(void __iomem *dst, struct iov_iter *iter, size_t count); 1597 1598 struct snd_pcm_status64 { 1599 snd_pcm_state_t state; /* stream state */ 1600 u8 rsvd[4]; 1601 s64 trigger_tstamp_sec; /* time when stream was started/stopped/paused */ 1602 s64 trigger_tstamp_nsec; 1603 s64 tstamp_sec; /* reference timestamp */ 1604 s64 tstamp_nsec; 1605 snd_pcm_uframes_t appl_ptr; /* appl ptr */ 1606 snd_pcm_uframes_t hw_ptr; /* hw ptr */ 1607 snd_pcm_sframes_t delay; /* current delay in frames */ 1608 snd_pcm_uframes_t avail; /* number of frames available */ 1609 snd_pcm_uframes_t avail_max; /* max frames available on hw since last status */ 1610 snd_pcm_uframes_t overrange; /* count of ADC (capture) overrange detections from last status */ 1611 snd_pcm_state_t suspended_state; /* suspended stream state */ 1612 __u32 audio_tstamp_data; /* needed for 64-bit alignment, used for configs/report to/from userspace */ 1613 s64 audio_tstamp_sec; /* sample counter, wall clock, PHC or on-demand sync'ed */ 1614 s64 audio_tstamp_nsec; 1615 s64 driver_tstamp_sec; /* useful in case reference system tstamp is reported with delay */ 1616 s64 driver_tstamp_nsec; 1617 __u32 audio_tstamp_accuracy; /* in ns units, only valid if indicated in audio_tstamp_data */ 1618 unsigned char reserved[52-4*sizeof(s64)]; /* must be filled with zero */ 1619 }; 1620 1621 #define SNDRV_PCM_IOCTL_STATUS64 _IOR('A', 0x20, struct snd_pcm_status64) 1622 #define SNDRV_PCM_IOCTL_STATUS_EXT64 _IOWR('A', 0x24, struct snd_pcm_status64) 1623 1624 struct snd_pcm_status32 { 1625 snd_pcm_state_t state; /* stream state */ 1626 s32 trigger_tstamp_sec; /* time when stream was started/stopped/paused */ 1627 s32 trigger_tstamp_nsec; 1628 s32 tstamp_sec; /* reference timestamp */ 1629 s32 tstamp_nsec; 1630 u32 appl_ptr; /* appl ptr */ 1631 u32 hw_ptr; /* hw ptr */ 1632 s32 delay; /* current delay in frames */ 1633 u32 avail; /* number of frames available */ 1634 u32 avail_max; /* max frames available on hw since last status */ 1635 u32 overrange; /* count of ADC (capture) overrange detections from last status */ 1636 snd_pcm_state_t suspended_state; /* suspended stream state */ 1637 u32 audio_tstamp_data; /* needed for 64-bit alignment, used for configs/report to/from userspace */ 1638 s32 audio_tstamp_sec; /* sample counter, wall clock, PHC or on-demand sync'ed */ 1639 s32 audio_tstamp_nsec; 1640 s32 driver_tstamp_sec; /* useful in case reference system tstamp is reported with delay */ 1641 s32 driver_tstamp_nsec; 1642 u32 audio_tstamp_accuracy; /* in ns units, only valid if indicated in audio_tstamp_data */ 1643 unsigned char reserved[52-4*sizeof(s32)]; /* must be filled with zero */ 1644 }; 1645 1646 #define SNDRV_PCM_IOCTL_STATUS32 _IOR('A', 0x20, struct snd_pcm_status32) 1647 #define SNDRV_PCM_IOCTL_STATUS_EXT32 _IOWR('A', 0x24, struct snd_pcm_status32) 1648 1649 #endif /* __SOUND_PCM_H */ 1650