1
2#ifndef __SOUND_PCM_H
3#define __SOUND_PCM_H
4
5
6
7
8
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
20#define snd_pcm_substream_chip(substream) ((substream)->private_data)
21#define snd_pcm_chip(pcm) ((pcm)->private_data)
22
23#if IS_ENABLED(CONFIG_SND_PCM_OSS)
24#include <sound/pcm_oss.h>
25#endif
26
27
28
29
30
31struct snd_pcm_hardware {
32 unsigned int info;
33 u64 formats;
34 unsigned int rates;
35 unsigned int rate_min;
36 unsigned int rate_max;
37 unsigned int channels_min;
38 unsigned int channels_max;
39 size_t buffer_bytes_max;
40 size_t period_bytes_min;
41 size_t period_bytes_max;
42 unsigned int periods_min;
43 unsigned int periods_max;
44 size_t fifo_size;
45};
46
47struct snd_pcm_status64;
48struct snd_pcm_substream;
49
50struct snd_pcm_audio_tstamp_config;
51struct snd_pcm_audio_tstamp_report;
52
53struct snd_pcm_ops {
54 int (*open)(struct snd_pcm_substream *substream);
55 int (*close)(struct snd_pcm_substream *substream);
56 int (*ioctl)(struct snd_pcm_substream * substream,
57 unsigned int cmd, void *arg);
58 int (*hw_params)(struct snd_pcm_substream *substream,
59 struct snd_pcm_hw_params *params);
60 int (*hw_free)(struct snd_pcm_substream *substream);
61 int (*prepare)(struct snd_pcm_substream *substream);
62 int (*trigger)(struct snd_pcm_substream *substream, int cmd);
63 int (*sync_stop)(struct snd_pcm_substream *substream);
64 snd_pcm_uframes_t (*pointer)(struct snd_pcm_substream *substream);
65 int (*get_time_info)(struct snd_pcm_substream *substream,
66 struct timespec64 *system_ts, struct timespec64 *audio_ts,
67 struct snd_pcm_audio_tstamp_config *audio_tstamp_config,
68 struct snd_pcm_audio_tstamp_report *audio_tstamp_report);
69 int (*fill_silence)(struct snd_pcm_substream *substream, int channel,
70 unsigned long pos, unsigned long bytes);
71 int (*copy_user)(struct snd_pcm_substream *substream, int channel,
72 unsigned long pos, void __user *buf,
73 unsigned long bytes);
74 int (*copy_kernel)(struct snd_pcm_substream *substream, int channel,
75 unsigned long pos, void *buf, unsigned long bytes);
76 struct page *(*page)(struct snd_pcm_substream *substream,
77 unsigned long offset);
78 int (*mmap)(struct snd_pcm_substream *substream, struct vm_area_struct *vma);
79 int (*ack)(struct snd_pcm_substream *substream);
80};
81
82
83
84
85
86#if defined(CONFIG_SND_DYNAMIC_MINORS)
87#define SNDRV_PCM_DEVICES (SNDRV_OS_MINORS-2)
88#else
89#define SNDRV_PCM_DEVICES 8
90#endif
91
92#define SNDRV_PCM_IOCTL1_RESET 0
93
94#define SNDRV_PCM_IOCTL1_CHANNEL_INFO 2
95
96#define SNDRV_PCM_IOCTL1_FIFO_SIZE 4
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
109#define SNDRV_PCM_RATE_5512 (1<<0)
110#define SNDRV_PCM_RATE_8000 (1<<1)
111#define SNDRV_PCM_RATE_11025 (1<<2)
112#define SNDRV_PCM_RATE_16000 (1<<3)
113#define SNDRV_PCM_RATE_22050 (1<<4)
114#define SNDRV_PCM_RATE_32000 (1<<5)
115#define SNDRV_PCM_RATE_44100 (1<<6)
116#define SNDRV_PCM_RATE_48000 (1<<7)
117#define SNDRV_PCM_RATE_64000 (1<<8)
118#define SNDRV_PCM_RATE_88200 (1<<9)
119#define SNDRV_PCM_RATE_96000 (1<<10)
120#define SNDRV_PCM_RATE_176400 (1<<11)
121#define SNDRV_PCM_RATE_192000 (1<<12)
122#define SNDRV_PCM_RATE_352800 (1<<13)
123#define SNDRV_PCM_RATE_384000 (1<<14)
124
125#define SNDRV_PCM_RATE_CONTINUOUS (1<<30)
126#define SNDRV_PCM_RATE_KNOT (1<<31)
127
128#define SNDRV_PCM_RATE_8000_44100 (SNDRV_PCM_RATE_8000|SNDRV_PCM_RATE_11025|\
129 SNDRV_PCM_RATE_16000|SNDRV_PCM_RATE_22050|\
130 SNDRV_PCM_RATE_32000|SNDRV_PCM_RATE_44100)
131#define SNDRV_PCM_RATE_8000_48000 (SNDRV_PCM_RATE_8000_44100|SNDRV_PCM_RATE_48000)
132#define SNDRV_PCM_RATE_8000_96000 (SNDRV_PCM_RATE_8000_48000|SNDRV_PCM_RATE_64000|\
133 SNDRV_PCM_RATE_88200|SNDRV_PCM_RATE_96000)
134#define SNDRV_PCM_RATE_8000_192000 (SNDRV_PCM_RATE_8000_96000|SNDRV_PCM_RATE_176400|\
135 SNDRV_PCM_RATE_192000)
136#define SNDRV_PCM_RATE_8000_384000 (SNDRV_PCM_RATE_8000_192000|\
137 SNDRV_PCM_RATE_352800|\
138 SNDRV_PCM_RATE_384000)
139#define _SNDRV_PCM_FMTBIT(fmt) (1ULL << (__force int)SNDRV_PCM_FORMAT_##fmt)
140#define SNDRV_PCM_FMTBIT_S8 _SNDRV_PCM_FMTBIT(S8)
141#define SNDRV_PCM_FMTBIT_U8 _SNDRV_PCM_FMTBIT(U8)
142#define SNDRV_PCM_FMTBIT_S16_LE _SNDRV_PCM_FMTBIT(S16_LE)
143#define SNDRV_PCM_FMTBIT_S16_BE _SNDRV_PCM_FMTBIT(S16_BE)
144#define SNDRV_PCM_FMTBIT_U16_LE _SNDRV_PCM_FMTBIT(U16_LE)
145#define SNDRV_PCM_FMTBIT_U16_BE _SNDRV_PCM_FMTBIT(U16_BE)
146#define SNDRV_PCM_FMTBIT_S24_LE _SNDRV_PCM_FMTBIT(S24_LE)
147#define SNDRV_PCM_FMTBIT_S24_BE _SNDRV_PCM_FMTBIT(S24_BE)
148#define SNDRV_PCM_FMTBIT_U24_LE _SNDRV_PCM_FMTBIT(U24_LE)
149#define SNDRV_PCM_FMTBIT_U24_BE _SNDRV_PCM_FMTBIT(U24_BE)
150
151
152
153#define SNDRV_PCM_FMTBIT_S32_LE _SNDRV_PCM_FMTBIT(S32_LE)
154#define SNDRV_PCM_FMTBIT_S32_BE _SNDRV_PCM_FMTBIT(S32_BE)
155#define SNDRV_PCM_FMTBIT_U32_LE _SNDRV_PCM_FMTBIT(U32_LE)
156#define SNDRV_PCM_FMTBIT_U32_BE _SNDRV_PCM_FMTBIT(U32_BE)
157#define SNDRV_PCM_FMTBIT_FLOAT_LE _SNDRV_PCM_FMTBIT(FLOAT_LE)
158#define SNDRV_PCM_FMTBIT_FLOAT_BE _SNDRV_PCM_FMTBIT(FLOAT_BE)
159#define SNDRV_PCM_FMTBIT_FLOAT64_LE _SNDRV_PCM_FMTBIT(FLOAT64_LE)
160#define SNDRV_PCM_FMTBIT_FLOAT64_BE _SNDRV_PCM_FMTBIT(FLOAT64_BE)
161#define SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE _SNDRV_PCM_FMTBIT(IEC958_SUBFRAME_LE)
162#define SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_BE _SNDRV_PCM_FMTBIT(IEC958_SUBFRAME_BE)
163#define SNDRV_PCM_FMTBIT_MU_LAW _SNDRV_PCM_FMTBIT(MU_LAW)
164#define SNDRV_PCM_FMTBIT_A_LAW _SNDRV_PCM_FMTBIT(A_LAW)
165#define SNDRV_PCM_FMTBIT_IMA_ADPCM _SNDRV_PCM_FMTBIT(IMA_ADPCM)
166#define SNDRV_PCM_FMTBIT_MPEG _SNDRV_PCM_FMTBIT(MPEG)
167#define SNDRV_PCM_FMTBIT_GSM _SNDRV_PCM_FMTBIT(GSM)
168#define SNDRV_PCM_FMTBIT_S20_LE _SNDRV_PCM_FMTBIT(S20_LE)
169#define SNDRV_PCM_FMTBIT_U20_LE _SNDRV_PCM_FMTBIT(U20_LE)
170#define SNDRV_PCM_FMTBIT_S20_BE _SNDRV_PCM_FMTBIT(S20_BE)
171#define SNDRV_PCM_FMTBIT_U20_BE _SNDRV_PCM_FMTBIT(U20_BE)
172#define SNDRV_PCM_FMTBIT_SPECIAL _SNDRV_PCM_FMTBIT(SPECIAL)
173#define SNDRV_PCM_FMTBIT_S24_3LE _SNDRV_PCM_FMTBIT(S24_3LE)
174#define SNDRV_PCM_FMTBIT_U24_3LE _SNDRV_PCM_FMTBIT(U24_3LE)
175#define SNDRV_PCM_FMTBIT_S24_3BE _SNDRV_PCM_FMTBIT(S24_3BE)
176#define SNDRV_PCM_FMTBIT_U24_3BE _SNDRV_PCM_FMTBIT(U24_3BE)
177#define SNDRV_PCM_FMTBIT_S20_3LE _SNDRV_PCM_FMTBIT(S20_3LE)
178#define SNDRV_PCM_FMTBIT_U20_3LE _SNDRV_PCM_FMTBIT(U20_3LE)
179#define SNDRV_PCM_FMTBIT_S20_3BE _SNDRV_PCM_FMTBIT(S20_3BE)
180#define SNDRV_PCM_FMTBIT_U20_3BE _SNDRV_PCM_FMTBIT(U20_3BE)
181#define SNDRV_PCM_FMTBIT_S18_3LE _SNDRV_PCM_FMTBIT(S18_3LE)
182#define SNDRV_PCM_FMTBIT_U18_3LE _SNDRV_PCM_FMTBIT(U18_3LE)
183#define SNDRV_PCM_FMTBIT_S18_3BE _SNDRV_PCM_FMTBIT(S18_3BE)
184#define SNDRV_PCM_FMTBIT_U18_3BE _SNDRV_PCM_FMTBIT(U18_3BE)
185#define SNDRV_PCM_FMTBIT_G723_24 _SNDRV_PCM_FMTBIT(G723_24)
186#define SNDRV_PCM_FMTBIT_G723_24_1B _SNDRV_PCM_FMTBIT(G723_24_1B)
187#define SNDRV_PCM_FMTBIT_G723_40 _SNDRV_PCM_FMTBIT(G723_40)
188#define SNDRV_PCM_FMTBIT_G723_40_1B _SNDRV_PCM_FMTBIT(G723_40_1B)
189#define SNDRV_PCM_FMTBIT_DSD_U8 _SNDRV_PCM_FMTBIT(DSD_U8)
190#define SNDRV_PCM_FMTBIT_DSD_U16_LE _SNDRV_PCM_FMTBIT(DSD_U16_LE)
191#define SNDRV_PCM_FMTBIT_DSD_U32_LE _SNDRV_PCM_FMTBIT(DSD_U32_LE)
192#define SNDRV_PCM_FMTBIT_DSD_U16_BE _SNDRV_PCM_FMTBIT(DSD_U16_BE)
193#define SNDRV_PCM_FMTBIT_DSD_U32_BE _SNDRV_PCM_FMTBIT(DSD_U32_BE)
194
195#ifdef SNDRV_LITTLE_ENDIAN
196#define SNDRV_PCM_FMTBIT_S16 SNDRV_PCM_FMTBIT_S16_LE
197#define SNDRV_PCM_FMTBIT_U16 SNDRV_PCM_FMTBIT_U16_LE
198#define SNDRV_PCM_FMTBIT_S24 SNDRV_PCM_FMTBIT_S24_LE
199#define SNDRV_PCM_FMTBIT_U24 SNDRV_PCM_FMTBIT_U24_LE
200#define SNDRV_PCM_FMTBIT_S32 SNDRV_PCM_FMTBIT_S32_LE
201#define SNDRV_PCM_FMTBIT_U32 SNDRV_PCM_FMTBIT_U32_LE
202#define SNDRV_PCM_FMTBIT_FLOAT SNDRV_PCM_FMTBIT_FLOAT_LE
203#define SNDRV_PCM_FMTBIT_FLOAT64 SNDRV_PCM_FMTBIT_FLOAT64_LE
204#define SNDRV_PCM_FMTBIT_IEC958_SUBFRAME SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE
205#define SNDRV_PCM_FMTBIT_S20 SNDRV_PCM_FMTBIT_S20_LE
206#define SNDRV_PCM_FMTBIT_U20 SNDRV_PCM_FMTBIT_U20_LE
207#endif
208#ifdef SNDRV_BIG_ENDIAN
209#define SNDRV_PCM_FMTBIT_S16 SNDRV_PCM_FMTBIT_S16_BE
210#define SNDRV_PCM_FMTBIT_U16 SNDRV_PCM_FMTBIT_U16_BE
211#define SNDRV_PCM_FMTBIT_S24 SNDRV_PCM_FMTBIT_S24_BE
212#define SNDRV_PCM_FMTBIT_U24 SNDRV_PCM_FMTBIT_U24_BE
213#define SNDRV_PCM_FMTBIT_S32 SNDRV_PCM_FMTBIT_S32_BE
214#define SNDRV_PCM_FMTBIT_U32 SNDRV_PCM_FMTBIT_U32_BE
215#define SNDRV_PCM_FMTBIT_FLOAT SNDRV_PCM_FMTBIT_FLOAT_BE
216#define SNDRV_PCM_FMTBIT_FLOAT64 SNDRV_PCM_FMTBIT_FLOAT64_BE
217#define SNDRV_PCM_FMTBIT_IEC958_SUBFRAME SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_BE
218#define SNDRV_PCM_FMTBIT_S20 SNDRV_PCM_FMTBIT_S20_BE
219#define SNDRV_PCM_FMTBIT_U20 SNDRV_PCM_FMTBIT_U20_BE
220#endif
221
222struct snd_pcm_file {
223 struct snd_pcm_substream *substream;
224 int no_compat_mmap;
225 unsigned int user_pversion;
226};
227
228struct snd_pcm_hw_rule;
229typedef int (*snd_pcm_hw_rule_func_t)(struct snd_pcm_hw_params *params,
230 struct snd_pcm_hw_rule *rule);
231
232struct snd_pcm_hw_rule {
233 unsigned int cond;
234 int var;
235 int deps[5];
236
237 snd_pcm_hw_rule_func_t func;
238 void *private;
239};
240
241struct snd_pcm_hw_constraints {
242 struct snd_mask masks[SNDRV_PCM_HW_PARAM_LAST_MASK -
243 SNDRV_PCM_HW_PARAM_FIRST_MASK + 1];
244 struct snd_interval intervals[SNDRV_PCM_HW_PARAM_LAST_INTERVAL -
245 SNDRV_PCM_HW_PARAM_FIRST_INTERVAL + 1];
246 unsigned int rules_num;
247 unsigned int rules_all;
248 struct snd_pcm_hw_rule *rules;
249};
250
251static inline struct snd_mask *constrs_mask(struct snd_pcm_hw_constraints *constrs,
252 snd_pcm_hw_param_t var)
253{
254 return &constrs->masks[var - SNDRV_PCM_HW_PARAM_FIRST_MASK];
255}
256
257static inline struct snd_interval *constrs_interval(struct snd_pcm_hw_constraints *constrs,
258 snd_pcm_hw_param_t var)
259{
260 return &constrs->intervals[var - SNDRV_PCM_HW_PARAM_FIRST_INTERVAL];
261}
262
263struct snd_ratnum {
264 unsigned int num;
265 unsigned int den_min, den_max, den_step;
266};
267
268struct snd_ratden {
269 unsigned int num_min, num_max, num_step;
270 unsigned int den;
271};
272
273struct snd_pcm_hw_constraint_ratnums {
274 int nrats;
275 const struct snd_ratnum *rats;
276};
277
278struct snd_pcm_hw_constraint_ratdens {
279 int nrats;
280 const struct snd_ratden *rats;
281};
282
283struct snd_pcm_hw_constraint_list {
284 const unsigned int *list;
285 unsigned int count;
286 unsigned int mask;
287};
288
289struct snd_pcm_hw_constraint_ranges {
290 unsigned int count;
291 const struct snd_interval *ranges;
292 unsigned int mask;
293};
294
295
296
297
298
299struct snd_pcm_audio_tstamp_config {
300
301 u32 type_requested:4;
302 u32 report_delay:1;
303};
304
305static inline void snd_pcm_unpack_audio_tstamp_config(__u32 data,
306 struct snd_pcm_audio_tstamp_config *config)
307{
308 config->type_requested = data & 0xF;
309 config->report_delay = (data >> 4) & 1;
310}
311
312
313
314
315
316struct snd_pcm_audio_tstamp_report {
317
318
319
320 u32 valid:1;
321
322
323 u32 actual_type:4;
324
325
326 u32 accuracy_report:1;
327 u32 accuracy;
328};
329
330static inline void snd_pcm_pack_audio_tstamp_report(__u32 *data, __u32 *accuracy,
331 const struct snd_pcm_audio_tstamp_report *report)
332{
333 u32 tmp;
334
335 tmp = report->accuracy_report;
336 tmp <<= 4;
337 tmp |= report->actual_type;
338 tmp <<= 1;
339 tmp |= report->valid;
340
341 *data &= 0xffff;
342 *data |= (tmp << 16);
343 *accuracy = report->accuracy;
344}
345
346
347struct snd_pcm_runtime {
348
349 struct snd_pcm_substream *trigger_master;
350 struct timespec64 trigger_tstamp;
351 bool trigger_tstamp_latched;
352 int overrange;
353 snd_pcm_uframes_t avail_max;
354 snd_pcm_uframes_t hw_ptr_base;
355 snd_pcm_uframes_t hw_ptr_interrupt;
356 unsigned long hw_ptr_jiffies;
357 unsigned long hw_ptr_buffer_jiffies;
358 snd_pcm_sframes_t delay;
359 u64 hw_ptr_wrap;
360
361
362 snd_pcm_access_t access;
363 snd_pcm_format_t format;
364 snd_pcm_subformat_t subformat;
365 unsigned int rate;
366 unsigned int channels;
367 snd_pcm_uframes_t period_size;
368 unsigned int periods;
369 snd_pcm_uframes_t buffer_size;
370 snd_pcm_uframes_t min_align;
371 size_t byte_align;
372 unsigned int frame_bits;
373 unsigned int sample_bits;
374 unsigned int info;
375 unsigned int rate_num;
376 unsigned int rate_den;
377 unsigned int no_period_wakeup: 1;
378
379
380 int tstamp_mode;
381 unsigned int period_step;
382 snd_pcm_uframes_t start_threshold;
383 snd_pcm_uframes_t stop_threshold;
384 snd_pcm_uframes_t silence_threshold;
385
386 snd_pcm_uframes_t silence_size;
387 snd_pcm_uframes_t boundary;
388
389 snd_pcm_uframes_t silence_start;
390 snd_pcm_uframes_t silence_filled;
391
392 union snd_pcm_sync_id sync;
393
394
395 struct snd_pcm_mmap_status *status;
396 struct snd_pcm_mmap_control *control;
397
398
399 snd_pcm_uframes_t twake;
400 wait_queue_head_t sleep;
401 wait_queue_head_t tsleep;
402 struct fasync_struct *fasync;
403 bool stop_operating;
404 struct mutex buffer_mutex;
405 atomic_t buffer_accessing;
406
407
408 void *private_data;
409 void (*private_free)(struct snd_pcm_runtime *runtime);
410
411
412 struct snd_pcm_hardware hw;
413 struct snd_pcm_hw_constraints hw_constraints;
414
415
416 unsigned int timer_resolution;
417 int tstamp_type;
418
419
420 unsigned char *dma_area;
421 dma_addr_t dma_addr;
422 size_t dma_bytes;
423
424 struct snd_dma_buffer *dma_buffer_p;
425 unsigned int buffer_changed:1;
426
427
428 struct snd_pcm_audio_tstamp_config audio_tstamp_config;
429 struct snd_pcm_audio_tstamp_report audio_tstamp_report;
430 struct timespec64 driver_tstamp;
431
432#if IS_ENABLED(CONFIG_SND_PCM_OSS)
433
434 struct snd_pcm_oss_runtime oss;
435#endif
436};
437
438struct snd_pcm_group {
439 spinlock_t lock;
440 struct mutex mutex;
441 struct list_head substreams;
442 refcount_t refs;
443};
444
445struct pid;
446
447struct snd_pcm_substream {
448 struct snd_pcm *pcm;
449 struct snd_pcm_str *pstr;
450 void *private_data;
451 int number;
452 char name[32];
453 int stream;
454 struct pm_qos_request latency_pm_qos_req;
455 size_t buffer_bytes_max;
456 struct snd_dma_buffer dma_buffer;
457 size_t dma_max;
458
459 const struct snd_pcm_ops *ops;
460
461 struct snd_pcm_runtime *runtime;
462
463 struct snd_timer *timer;
464 unsigned timer_running: 1;
465 long wait_time;
466
467 struct snd_pcm_substream *next;
468
469 struct list_head link_list;
470 struct snd_pcm_group self_group;
471 struct snd_pcm_group *group;
472
473 int ref_count;
474 atomic_t mmap_count;
475 unsigned int f_flags;
476 void (*pcm_release)(struct snd_pcm_substream *);
477 struct pid *pid;
478#if IS_ENABLED(CONFIG_SND_PCM_OSS)
479
480 struct snd_pcm_oss_substream oss;
481#endif
482#ifdef CONFIG_SND_VERBOSE_PROCFS
483 struct snd_info_entry *proc_root;
484#endif
485
486 unsigned int hw_opened: 1;
487 unsigned int managed_buffer_alloc:1;
488};
489
490#define SUBSTREAM_BUSY(substream) ((substream)->ref_count > 0)
491
492
493struct snd_pcm_str {
494 int stream;
495 struct snd_pcm *pcm;
496
497 unsigned int substream_count;
498 unsigned int substream_opened;
499 struct snd_pcm_substream *substream;
500#if IS_ENABLED(CONFIG_SND_PCM_OSS)
501
502 struct snd_pcm_oss_stream oss;
503#endif
504#ifdef CONFIG_SND_VERBOSE_PROCFS
505 struct snd_info_entry *proc_root;
506#ifdef CONFIG_SND_PCM_XRUN_DEBUG
507 unsigned int xrun_debug;
508#endif
509#endif
510 struct snd_kcontrol *chmap_kctl;
511 struct device dev;
512};
513
514struct snd_pcm {
515 struct snd_card *card;
516 struct list_head list;
517 int device;
518 unsigned int info_flags;
519 unsigned short dev_class;
520 unsigned short dev_subclass;
521 char id[64];
522 char name[80];
523 struct snd_pcm_str streams[2];
524 struct mutex open_mutex;
525 wait_queue_head_t open_wait;
526 void *private_data;
527 void (*private_free) (struct snd_pcm *pcm);
528 bool internal;
529 bool nonatomic;
530 bool no_device_suspend;
531#if IS_ENABLED(CONFIG_SND_PCM_OSS)
532 struct snd_pcm_oss oss;
533#endif
534};
535
536
537
538
539
540extern const struct file_operations snd_pcm_f_ops[2];
541
542int snd_pcm_new(struct snd_card *card, const char *id, int device,
543 int playback_count, int capture_count,
544 struct snd_pcm **rpcm);
545int snd_pcm_new_internal(struct snd_card *card, const char *id, int device,
546 int playback_count, int capture_count,
547 struct snd_pcm **rpcm);
548int snd_pcm_new_stream(struct snd_pcm *pcm, int stream, int substream_count);
549
550#if IS_ENABLED(CONFIG_SND_PCM_OSS)
551struct snd_pcm_notify {
552 int (*n_register) (struct snd_pcm * pcm);
553 int (*n_disconnect) (struct snd_pcm * pcm);
554 int (*n_unregister) (struct snd_pcm * pcm);
555 struct list_head list;
556};
557int snd_pcm_notify(struct snd_pcm_notify *notify, int nfree);
558#endif
559
560
561
562
563
564int snd_pcm_info(struct snd_pcm_substream *substream, struct snd_pcm_info *info);
565int snd_pcm_info_user(struct snd_pcm_substream *substream,
566 struct snd_pcm_info __user *info);
567int snd_pcm_status64(struct snd_pcm_substream *substream,
568 struct snd_pcm_status64 *status);
569int snd_pcm_start(struct snd_pcm_substream *substream);
570int snd_pcm_stop(struct snd_pcm_substream *substream, snd_pcm_state_t status);
571int snd_pcm_drain_done(struct snd_pcm_substream *substream);
572int snd_pcm_stop_xrun(struct snd_pcm_substream *substream);
573#ifdef CONFIG_PM
574int snd_pcm_suspend_all(struct snd_pcm *pcm);
575#else
576static inline int snd_pcm_suspend_all(struct snd_pcm *pcm)
577{
578 return 0;
579}
580#endif
581int snd_pcm_kernel_ioctl(struct snd_pcm_substream *substream, unsigned int cmd, void *arg);
582int snd_pcm_open_substream(struct snd_pcm *pcm, int stream, struct file *file,
583 struct snd_pcm_substream **rsubstream);
584void snd_pcm_release_substream(struct snd_pcm_substream *substream);
585int snd_pcm_attach_substream(struct snd_pcm *pcm, int stream, struct file *file,
586 struct snd_pcm_substream **rsubstream);
587void snd_pcm_detach_substream(struct snd_pcm_substream *substream);
588int snd_pcm_mmap_data(struct snd_pcm_substream *substream, struct file *file, struct vm_area_struct *area);
589
590
591#ifdef CONFIG_SND_DEBUG
592void snd_pcm_debug_name(struct snd_pcm_substream *substream,
593 char *name, size_t len);
594#else
595static inline void
596snd_pcm_debug_name(struct snd_pcm_substream *substream, char *buf, size_t size)
597{
598 *buf = 0;
599}
600#endif
601
602
603
604
605
606
607
608
609
610
611
612static inline int snd_pcm_stream_linked(struct snd_pcm_substream *substream)
613{
614 return substream->group != &substream->self_group;
615}
616
617void snd_pcm_stream_lock(struct snd_pcm_substream *substream);
618void snd_pcm_stream_unlock(struct snd_pcm_substream *substream);
619void snd_pcm_stream_lock_irq(struct snd_pcm_substream *substream);
620void snd_pcm_stream_unlock_irq(struct snd_pcm_substream *substream);
621unsigned long _snd_pcm_stream_lock_irqsave(struct snd_pcm_substream *substream);
622unsigned long _snd_pcm_stream_lock_irqsave_nested(struct snd_pcm_substream *substream);
623
624
625
626
627
628
629
630
631
632
633#define snd_pcm_stream_lock_irqsave(substream, flags) \
634 do { \
635 typecheck(unsigned long, flags); \
636 flags = _snd_pcm_stream_lock_irqsave(substream); \
637 } while (0)
638void snd_pcm_stream_unlock_irqrestore(struct snd_pcm_substream *substream,
639 unsigned long flags);
640
641
642
643
644
645
646
647
648
649#define snd_pcm_stream_lock_irqsave_nested(substream, flags) \
650 do { \
651 typecheck(unsigned long, flags); \
652 flags = _snd_pcm_stream_lock_irqsave_nested(substream); \
653 } while (0)
654
655
656
657
658
659
660
661
662
663
664#define snd_pcm_group_for_each_entry(s, substream) \
665 list_for_each_entry(s, &substream->group->substreams, link_list)
666
667#define for_each_pcm_streams(stream) \
668 for (stream = SNDRV_PCM_STREAM_PLAYBACK; \
669 stream <= SNDRV_PCM_STREAM_LAST; \
670 stream++)
671
672
673
674
675
676
677
678
679static inline int snd_pcm_running(struct snd_pcm_substream *substream)
680{
681 return (substream->runtime->status->state == SNDRV_PCM_STATE_RUNNING ||
682 (substream->runtime->status->state == SNDRV_PCM_STATE_DRAINING &&
683 substream->stream == SNDRV_PCM_STREAM_PLAYBACK));
684}
685
686
687
688
689
690
691static inline ssize_t bytes_to_samples(struct snd_pcm_runtime *runtime, ssize_t size)
692{
693 return size * 8 / runtime->sample_bits;
694}
695
696
697
698
699
700
701static inline snd_pcm_sframes_t bytes_to_frames(struct snd_pcm_runtime *runtime, ssize_t size)
702{
703 return size * 8 / runtime->frame_bits;
704}
705
706
707
708
709
710
711static inline ssize_t samples_to_bytes(struct snd_pcm_runtime *runtime, ssize_t size)
712{
713 return size * runtime->sample_bits / 8;
714}
715
716
717
718
719
720
721static inline ssize_t frames_to_bytes(struct snd_pcm_runtime *runtime, snd_pcm_sframes_t size)
722{
723 return size * runtime->frame_bits / 8;
724}
725
726
727
728
729
730
731static inline int frame_aligned(struct snd_pcm_runtime *runtime, ssize_t bytes)
732{
733 return bytes % runtime->byte_align == 0;
734}
735
736
737
738
739
740static inline size_t snd_pcm_lib_buffer_bytes(struct snd_pcm_substream *substream)
741{
742 struct snd_pcm_runtime *runtime = substream->runtime;
743 return frames_to_bytes(runtime, runtime->buffer_size);
744}
745
746
747
748
749
750static inline size_t snd_pcm_lib_period_bytes(struct snd_pcm_substream *substream)
751{
752 struct snd_pcm_runtime *runtime = substream->runtime;
753 return frames_to_bytes(runtime, runtime->period_size);
754}
755
756
757
758
759
760
761
762static inline snd_pcm_uframes_t snd_pcm_playback_avail(struct snd_pcm_runtime *runtime)
763{
764 snd_pcm_sframes_t avail = runtime->status->hw_ptr + runtime->buffer_size - runtime->control->appl_ptr;
765 if (avail < 0)
766 avail += runtime->boundary;
767 else if ((snd_pcm_uframes_t) avail >= runtime->boundary)
768 avail -= runtime->boundary;
769 return avail;
770}
771
772
773
774
775
776
777
778static inline snd_pcm_uframes_t snd_pcm_capture_avail(struct snd_pcm_runtime *runtime)
779{
780 snd_pcm_sframes_t avail = runtime->status->hw_ptr - runtime->control->appl_ptr;
781 if (avail < 0)
782 avail += runtime->boundary;
783 return avail;
784}
785
786
787
788
789
790static inline snd_pcm_sframes_t snd_pcm_playback_hw_avail(struct snd_pcm_runtime *runtime)
791{
792 return runtime->buffer_size - snd_pcm_playback_avail(runtime);
793}
794
795
796
797
798
799static inline snd_pcm_sframes_t snd_pcm_capture_hw_avail(struct snd_pcm_runtime *runtime)
800{
801 return runtime->buffer_size - snd_pcm_capture_avail(runtime);
802}
803
804
805
806
807
808
809
810
811
812static inline int snd_pcm_playback_ready(struct snd_pcm_substream *substream)
813{
814 struct snd_pcm_runtime *runtime = substream->runtime;
815 return snd_pcm_playback_avail(runtime) >= runtime->control->avail_min;
816}
817
818
819
820
821
822
823
824
825
826static inline int snd_pcm_capture_ready(struct snd_pcm_substream *substream)
827{
828 struct snd_pcm_runtime *runtime = substream->runtime;
829 return snd_pcm_capture_avail(runtime) >= runtime->control->avail_min;
830}
831
832
833
834
835
836
837
838
839
840
841static inline int snd_pcm_playback_data(struct snd_pcm_substream *substream)
842{
843 struct snd_pcm_runtime *runtime = substream->runtime;
844
845 if (runtime->stop_threshold >= runtime->boundary)
846 return 1;
847 return snd_pcm_playback_avail(runtime) < runtime->buffer_size;
848}
849
850
851
852
853
854
855
856
857
858static inline int snd_pcm_playback_empty(struct snd_pcm_substream *substream)
859{
860 struct snd_pcm_runtime *runtime = substream->runtime;
861 return snd_pcm_playback_avail(runtime) >= runtime->buffer_size;
862}
863
864
865
866
867
868
869
870
871
872static inline int snd_pcm_capture_empty(struct snd_pcm_substream *substream)
873{
874 struct snd_pcm_runtime *runtime = substream->runtime;
875 return snd_pcm_capture_avail(runtime) == 0;
876}
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892static inline void snd_pcm_trigger_done(struct snd_pcm_substream *substream,
893 struct snd_pcm_substream *master)
894{
895 substream->runtime->trigger_master = master;
896}
897
898static inline int hw_is_mask(int var)
899{
900 return var >= SNDRV_PCM_HW_PARAM_FIRST_MASK &&
901 var <= SNDRV_PCM_HW_PARAM_LAST_MASK;
902}
903
904static inline int hw_is_interval(int var)
905{
906 return var >= SNDRV_PCM_HW_PARAM_FIRST_INTERVAL &&
907 var <= SNDRV_PCM_HW_PARAM_LAST_INTERVAL;
908}
909
910static inline struct snd_mask *hw_param_mask(struct snd_pcm_hw_params *params,
911 snd_pcm_hw_param_t var)
912{
913 return ¶ms->masks[var - SNDRV_PCM_HW_PARAM_FIRST_MASK];
914}
915
916static inline struct snd_interval *hw_param_interval(struct snd_pcm_hw_params *params,
917 snd_pcm_hw_param_t var)
918{
919 return ¶ms->intervals[var - SNDRV_PCM_HW_PARAM_FIRST_INTERVAL];
920}
921
922static inline const struct snd_mask *hw_param_mask_c(const struct snd_pcm_hw_params *params,
923 snd_pcm_hw_param_t var)
924{
925 return ¶ms->masks[var - SNDRV_PCM_HW_PARAM_FIRST_MASK];
926}
927
928static inline const struct snd_interval *hw_param_interval_c(const struct snd_pcm_hw_params *params,
929 snd_pcm_hw_param_t var)
930{
931 return ¶ms->intervals[var - SNDRV_PCM_HW_PARAM_FIRST_INTERVAL];
932}
933
934
935
936
937
938static inline unsigned int params_channels(const struct snd_pcm_hw_params *p)
939{
940 return hw_param_interval_c(p, SNDRV_PCM_HW_PARAM_CHANNELS)->min;
941}
942
943
944
945
946
947static inline unsigned int params_rate(const struct snd_pcm_hw_params *p)
948{
949 return hw_param_interval_c(p, SNDRV_PCM_HW_PARAM_RATE)->min;
950}
951
952
953
954
955
956static inline unsigned int params_period_size(const struct snd_pcm_hw_params *p)
957{
958 return hw_param_interval_c(p, SNDRV_PCM_HW_PARAM_PERIOD_SIZE)->min;
959}
960
961
962
963
964
965static inline unsigned int params_periods(const struct snd_pcm_hw_params *p)
966{
967 return hw_param_interval_c(p, SNDRV_PCM_HW_PARAM_PERIODS)->min;
968}
969
970
971
972
973
974static inline unsigned int params_buffer_size(const struct snd_pcm_hw_params *p)
975{
976 return hw_param_interval_c(p, SNDRV_PCM_HW_PARAM_BUFFER_SIZE)->min;
977}
978
979
980
981
982
983static inline unsigned int params_buffer_bytes(const struct snd_pcm_hw_params *p)
984{
985 return hw_param_interval_c(p, SNDRV_PCM_HW_PARAM_BUFFER_BYTES)->min;
986}
987
988int snd_interval_refine(struct snd_interval *i, const struct snd_interval *v);
989int snd_interval_list(struct snd_interval *i, unsigned int count,
990 const unsigned int *list, unsigned int mask);
991int snd_interval_ranges(struct snd_interval *i, unsigned int count,
992 const struct snd_interval *list, unsigned int mask);
993int snd_interval_ratnum(struct snd_interval *i,
994 unsigned int rats_count, const struct snd_ratnum *rats,
995 unsigned int *nump, unsigned int *denp);
996
997void _snd_pcm_hw_params_any(struct snd_pcm_hw_params *params);
998void _snd_pcm_hw_param_setempty(struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var);
999
1000int snd_pcm_hw_refine(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params);
1001
1002int snd_pcm_hw_constraint_mask64(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var,
1003 u_int64_t mask);
1004int snd_pcm_hw_constraint_minmax(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var,
1005 unsigned int min, unsigned int max);
1006int snd_pcm_hw_constraint_integer(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var);
1007int snd_pcm_hw_constraint_list(struct snd_pcm_runtime *runtime,
1008 unsigned int cond,
1009 snd_pcm_hw_param_t var,
1010 const struct snd_pcm_hw_constraint_list *l);
1011int snd_pcm_hw_constraint_ranges(struct snd_pcm_runtime *runtime,
1012 unsigned int cond,
1013 snd_pcm_hw_param_t var,
1014 const struct snd_pcm_hw_constraint_ranges *r);
1015int snd_pcm_hw_constraint_ratnums(struct snd_pcm_runtime *runtime,
1016 unsigned int cond,
1017 snd_pcm_hw_param_t var,
1018 const struct snd_pcm_hw_constraint_ratnums *r);
1019int snd_pcm_hw_constraint_ratdens(struct snd_pcm_runtime *runtime,
1020 unsigned int cond,
1021 snd_pcm_hw_param_t var,
1022 const struct snd_pcm_hw_constraint_ratdens *r);
1023int snd_pcm_hw_constraint_msbits(struct snd_pcm_runtime *runtime,
1024 unsigned int cond,
1025 unsigned int width,
1026 unsigned int msbits);
1027int snd_pcm_hw_constraint_step(struct snd_pcm_runtime *runtime,
1028 unsigned int cond,
1029 snd_pcm_hw_param_t var,
1030 unsigned long step);
1031int snd_pcm_hw_constraint_pow2(struct snd_pcm_runtime *runtime,
1032 unsigned int cond,
1033 snd_pcm_hw_param_t var);
1034int snd_pcm_hw_rule_noresample(struct snd_pcm_runtime *runtime,
1035 unsigned int base_rate);
1036int snd_pcm_hw_rule_add(struct snd_pcm_runtime *runtime,
1037 unsigned int cond,
1038 int var,
1039 snd_pcm_hw_rule_func_t func, void *private,
1040 int dep, ...);
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051static inline int snd_pcm_hw_constraint_single(
1052 struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var,
1053 unsigned int val)
1054{
1055 return snd_pcm_hw_constraint_minmax(runtime, var, val, val);
1056}
1057
1058int snd_pcm_format_signed(snd_pcm_format_t format);
1059int snd_pcm_format_unsigned(snd_pcm_format_t format);
1060int snd_pcm_format_linear(snd_pcm_format_t format);
1061int snd_pcm_format_little_endian(snd_pcm_format_t format);
1062int snd_pcm_format_big_endian(snd_pcm_format_t format);
1063#if 0
1064
1065
1066
1067
1068
1069
1070
1071int snd_pcm_format_cpu_endian(snd_pcm_format_t format);
1072#endif
1073#ifdef SNDRV_LITTLE_ENDIAN
1074#define snd_pcm_format_cpu_endian(format) snd_pcm_format_little_endian(format)
1075#else
1076#define snd_pcm_format_cpu_endian(format) snd_pcm_format_big_endian(format)
1077#endif
1078int snd_pcm_format_width(snd_pcm_format_t format);
1079int snd_pcm_format_physical_width(snd_pcm_format_t format);
1080ssize_t snd_pcm_format_size(snd_pcm_format_t format, size_t samples);
1081const unsigned char *snd_pcm_format_silence_64(snd_pcm_format_t format);
1082int snd_pcm_format_set_silence(snd_pcm_format_t format, void *buf, unsigned int frames);
1083
1084void snd_pcm_set_ops(struct snd_pcm * pcm, int direction,
1085 const struct snd_pcm_ops *ops);
1086void snd_pcm_set_sync(struct snd_pcm_substream *substream);
1087int snd_pcm_lib_ioctl(struct snd_pcm_substream *substream,
1088 unsigned int cmd, void *arg);
1089void snd_pcm_period_elapsed_under_stream_lock(struct snd_pcm_substream *substream);
1090void snd_pcm_period_elapsed(struct snd_pcm_substream *substream);
1091snd_pcm_sframes_t __snd_pcm_lib_xfer(struct snd_pcm_substream *substream,
1092 void *buf, bool interleaved,
1093 snd_pcm_uframes_t frames, bool in_kernel);
1094
1095static inline snd_pcm_sframes_t
1096snd_pcm_lib_write(struct snd_pcm_substream *substream,
1097 const void __user *buf, snd_pcm_uframes_t frames)
1098{
1099 return __snd_pcm_lib_xfer(substream, (void __force *)buf, true, frames, false);
1100}
1101
1102static inline snd_pcm_sframes_t
1103snd_pcm_lib_read(struct snd_pcm_substream *substream,
1104 void __user *buf, snd_pcm_uframes_t frames)
1105{
1106 return __snd_pcm_lib_xfer(substream, (void __force *)buf, true, frames, false);
1107}
1108
1109static inline snd_pcm_sframes_t
1110snd_pcm_lib_writev(struct snd_pcm_substream *substream,
1111 void __user **bufs, snd_pcm_uframes_t frames)
1112{
1113 return __snd_pcm_lib_xfer(substream, (void *)bufs, false, frames, false);
1114}
1115
1116static inline snd_pcm_sframes_t
1117snd_pcm_lib_readv(struct snd_pcm_substream *substream,
1118 void __user **bufs, snd_pcm_uframes_t frames)
1119{
1120 return __snd_pcm_lib_xfer(substream, (void *)bufs, false, frames, false);
1121}
1122
1123static inline snd_pcm_sframes_t
1124snd_pcm_kernel_write(struct snd_pcm_substream *substream,
1125 const void *buf, snd_pcm_uframes_t frames)
1126{
1127 return __snd_pcm_lib_xfer(substream, (void *)buf, true, frames, true);
1128}
1129
1130static inline snd_pcm_sframes_t
1131snd_pcm_kernel_read(struct snd_pcm_substream *substream,
1132 void *buf, snd_pcm_uframes_t frames)
1133{
1134 return __snd_pcm_lib_xfer(substream, buf, true, frames, true);
1135}
1136
1137static inline snd_pcm_sframes_t
1138snd_pcm_kernel_writev(struct snd_pcm_substream *substream,
1139 void **bufs, snd_pcm_uframes_t frames)
1140{
1141 return __snd_pcm_lib_xfer(substream, bufs, false, frames, true);
1142}
1143
1144static inline snd_pcm_sframes_t
1145snd_pcm_kernel_readv(struct snd_pcm_substream *substream,
1146 void **bufs, snd_pcm_uframes_t frames)
1147{
1148 return __snd_pcm_lib_xfer(substream, bufs, false, frames, true);
1149}
1150
1151int snd_pcm_hw_limit_rates(struct snd_pcm_hardware *hw);
1152
1153static inline int
1154snd_pcm_limit_hw_rates(struct snd_pcm_runtime *runtime)
1155{
1156 return snd_pcm_hw_limit_rates(&runtime->hw);
1157}
1158
1159unsigned int snd_pcm_rate_to_rate_bit(unsigned int rate);
1160unsigned int snd_pcm_rate_bit_to_rate(unsigned int rate_bit);
1161unsigned int snd_pcm_rate_mask_intersect(unsigned int rates_a,
1162 unsigned int rates_b);
1163unsigned int snd_pcm_rate_range_to_bits(unsigned int rate_min,
1164 unsigned int rate_max);
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174static inline void snd_pcm_set_runtime_buffer(struct snd_pcm_substream *substream,
1175 struct snd_dma_buffer *bufp)
1176{
1177 struct snd_pcm_runtime *runtime = substream->runtime;
1178 if (bufp) {
1179 runtime->dma_buffer_p = bufp;
1180 runtime->dma_area = bufp->area;
1181 runtime->dma_addr = bufp->addr;
1182 runtime->dma_bytes = bufp->bytes;
1183 } else {
1184 runtime->dma_buffer_p = NULL;
1185 runtime->dma_area = NULL;
1186 runtime->dma_addr = 0;
1187 runtime->dma_bytes = 0;
1188 }
1189}
1190
1191
1192
1193
1194
1195
1196static inline void snd_pcm_gettime(struct snd_pcm_runtime *runtime,
1197 struct timespec64 *tv)
1198{
1199 switch (runtime->tstamp_type) {
1200 case SNDRV_PCM_TSTAMP_TYPE_MONOTONIC:
1201 ktime_get_ts64(tv);
1202 break;
1203 case SNDRV_PCM_TSTAMP_TYPE_MONOTONIC_RAW:
1204 ktime_get_raw_ts64(tv);
1205 break;
1206 default:
1207 ktime_get_real_ts64(tv);
1208 break;
1209 }
1210}
1211
1212
1213
1214
1215
1216void snd_pcm_lib_preallocate_free(struct snd_pcm_substream *substream);
1217void snd_pcm_lib_preallocate_free_for_all(struct snd_pcm *pcm);
1218void snd_pcm_lib_preallocate_pages(struct snd_pcm_substream *substream,
1219 int type, struct device *data,
1220 size_t size, size_t max);
1221void snd_pcm_lib_preallocate_pages_for_all(struct snd_pcm *pcm,
1222 int type, void *data,
1223 size_t size, size_t max);
1224int snd_pcm_lib_malloc_pages(struct snd_pcm_substream *substream, size_t size);
1225int snd_pcm_lib_free_pages(struct snd_pcm_substream *substream);
1226
1227int snd_pcm_set_managed_buffer(struct snd_pcm_substream *substream, int type,
1228 struct device *data, size_t size, size_t max);
1229int snd_pcm_set_managed_buffer_all(struct snd_pcm *pcm, int type,
1230 struct device *data,
1231 size_t size, size_t max);
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245static inline int __must_check
1246snd_pcm_set_fixed_buffer(struct snd_pcm_substream *substream, int type,
1247 struct device *data, size_t size)
1248{
1249 return snd_pcm_set_managed_buffer(substream, type, data, size, 0);
1250}
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263static inline int __must_check
1264snd_pcm_set_fixed_buffer_all(struct snd_pcm *pcm, int type,
1265 struct device *data, size_t size)
1266{
1267 return snd_pcm_set_managed_buffer_all(pcm, type, data, size, 0);
1268}
1269
1270int _snd_pcm_lib_alloc_vmalloc_buffer(struct snd_pcm_substream *substream,
1271 size_t size, gfp_t gfp_flags);
1272int snd_pcm_lib_free_vmalloc_buffer(struct snd_pcm_substream *substream);
1273struct page *snd_pcm_lib_get_vmalloc_page(struct snd_pcm_substream *substream,
1274 unsigned long offset);
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287static inline int snd_pcm_lib_alloc_vmalloc_buffer
1288 (struct snd_pcm_substream *substream, size_t size)
1289{
1290 return _snd_pcm_lib_alloc_vmalloc_buffer(substream, size,
1291 GFP_KERNEL | __GFP_HIGHMEM | __GFP_ZERO);
1292}
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305static inline int snd_pcm_lib_alloc_vmalloc_32_buffer
1306 (struct snd_pcm_substream *substream, size_t size)
1307{
1308 return _snd_pcm_lib_alloc_vmalloc_buffer(substream, size,
1309 GFP_KERNEL | GFP_DMA32 | __GFP_ZERO);
1310}
1311
1312#define snd_pcm_get_dma_buf(substream) ((substream)->runtime->dma_buffer_p)
1313
1314
1315
1316
1317
1318
1319static inline dma_addr_t
1320snd_pcm_sgbuf_get_addr(struct snd_pcm_substream *substream, unsigned int ofs)
1321{
1322 return snd_sgbuf_get_addr(snd_pcm_get_dma_buf(substream), ofs);
1323}
1324
1325
1326
1327
1328
1329
1330
1331
1332static inline unsigned int
1333snd_pcm_sgbuf_get_chunk_size(struct snd_pcm_substream *substream,
1334 unsigned int ofs, unsigned int size)
1335{
1336 return snd_sgbuf_get_chunk_size(snd_pcm_get_dma_buf(substream), ofs, size);
1337}
1338
1339
1340
1341
1342
1343
1344
1345static inline void snd_pcm_mmap_data_open(struct vm_area_struct *area)
1346{
1347 struct snd_pcm_substream *substream = (struct snd_pcm_substream *)area->vm_private_data;
1348 atomic_inc(&substream->mmap_count);
1349}
1350
1351
1352
1353
1354
1355
1356
1357static inline void snd_pcm_mmap_data_close(struct vm_area_struct *area)
1358{
1359 struct snd_pcm_substream *substream = (struct snd_pcm_substream *)area->vm_private_data;
1360 atomic_dec(&substream->mmap_count);
1361}
1362
1363int snd_pcm_lib_default_mmap(struct snd_pcm_substream *substream,
1364 struct vm_area_struct *area);
1365
1366#if defined(CONFIG_X86) || defined(CONFIG_PPC) || defined(CONFIG_ALPHA)
1367#define SNDRV_PCM_INFO_MMAP_IOMEM SNDRV_PCM_INFO_MMAP
1368int snd_pcm_lib_mmap_iomem(struct snd_pcm_substream *substream, struct vm_area_struct *area);
1369#else
1370#define SNDRV_PCM_INFO_MMAP_IOMEM 0
1371#define snd_pcm_lib_mmap_iomem NULL
1372#endif
1373
1374
1375
1376
1377
1378
1379static inline void snd_pcm_limit_isa_dma_size(int dma, size_t *max)
1380{
1381 *max = dma < 4 ? 64 * 1024 : 128 * 1024;
1382}
1383
1384
1385
1386
1387
1388#define SNDRV_PCM_DEFAULT_CON_SPDIF (IEC958_AES0_CON_EMPHASIS_NONE|\
1389 (IEC958_AES1_CON_ORIGINAL<<8)|\
1390 (IEC958_AES1_CON_PCM_CODER<<8)|\
1391 (IEC958_AES3_CON_FS_48000<<24))
1392
1393const char *snd_pcm_format_name(snd_pcm_format_t format);
1394
1395
1396
1397
1398
1399
1400
1401static inline const char *snd_pcm_stream_str(struct snd_pcm_substream *substream)
1402{
1403 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
1404 return "Playback";
1405 else
1406 return "Capture";
1407}
1408
1409
1410
1411
1412
1413struct snd_pcm_chmap_elem {
1414 unsigned char channels;
1415 unsigned char map[15];
1416};
1417
1418
1419struct snd_pcm_chmap {
1420 struct snd_pcm *pcm;
1421 int stream;
1422 struct snd_kcontrol *kctl;
1423 const struct snd_pcm_chmap_elem *chmap;
1424 unsigned int max_channels;
1425 unsigned int channel_mask;
1426 void *private_data;
1427};
1428
1429
1430
1431
1432
1433
1434static inline struct snd_pcm_substream *
1435snd_pcm_chmap_substream(struct snd_pcm_chmap *info, unsigned int idx)
1436{
1437 struct snd_pcm_substream *s;
1438 for (s = info->pcm->streams[info->stream].substream; s; s = s->next)
1439 if (s->number == idx)
1440 return s;
1441 return NULL;
1442}
1443
1444
1445extern const struct snd_pcm_chmap_elem snd_pcm_std_chmaps[];
1446
1447extern const struct snd_pcm_chmap_elem snd_pcm_alt_chmaps[];
1448
1449
1450#define SND_PCM_CHMAP_MASK_24 ((1U << 2) | (1U << 4))
1451#define SND_PCM_CHMAP_MASK_246 (SND_PCM_CHMAP_MASK_24 | (1U << 6))
1452#define SND_PCM_CHMAP_MASK_2468 (SND_PCM_CHMAP_MASK_246 | (1U << 8))
1453
1454int snd_pcm_add_chmap_ctls(struct snd_pcm *pcm, int stream,
1455 const struct snd_pcm_chmap_elem *chmap,
1456 int max_channels,
1457 unsigned long private_value,
1458 struct snd_pcm_chmap **info_ret);
1459
1460
1461
1462
1463
1464static inline u64 pcm_format_to_bits(snd_pcm_format_t pcm_format)
1465{
1466 return 1ULL << (__force int) pcm_format;
1467}
1468
1469
1470
1471
1472
1473#define pcm_for_each_format(f) \
1474 for ((f) = SNDRV_PCM_FORMAT_FIRST; \
1475 (__force int)(f) <= (__force int)SNDRV_PCM_FORMAT_LAST; \
1476 (f) = (__force snd_pcm_format_t)((__force int)(f) + 1))
1477
1478
1479#define pcm_err(pcm, fmt, args...) \
1480 dev_err((pcm)->card->dev, fmt, ##args)
1481#define pcm_warn(pcm, fmt, args...) \
1482 dev_warn((pcm)->card->dev, fmt, ##args)
1483#define pcm_dbg(pcm, fmt, args...) \
1484 dev_dbg((pcm)->card->dev, fmt, ##args)
1485
1486struct snd_pcm_status64 {
1487 snd_pcm_state_t state;
1488 u8 rsvd[4];
1489 s64 trigger_tstamp_sec;
1490 s64 trigger_tstamp_nsec;
1491 s64 tstamp_sec;
1492 s64 tstamp_nsec;
1493 snd_pcm_uframes_t appl_ptr;
1494 snd_pcm_uframes_t hw_ptr;
1495 snd_pcm_sframes_t delay;
1496 snd_pcm_uframes_t avail;
1497 snd_pcm_uframes_t avail_max;
1498 snd_pcm_uframes_t overrange;
1499 snd_pcm_state_t suspended_state;
1500 __u32 audio_tstamp_data;
1501 s64 audio_tstamp_sec;
1502 s64 audio_tstamp_nsec;
1503 s64 driver_tstamp_sec;
1504 s64 driver_tstamp_nsec;
1505 __u32 audio_tstamp_accuracy;
1506 unsigned char reserved[52-4*sizeof(s64)];
1507};
1508
1509#define SNDRV_PCM_IOCTL_STATUS64 _IOR('A', 0x20, struct snd_pcm_status64)
1510#define SNDRV_PCM_IOCTL_STATUS_EXT64 _IOWR('A', 0x24, struct snd_pcm_status64)
1511
1512struct snd_pcm_status32 {
1513 snd_pcm_state_t state;
1514 s32 trigger_tstamp_sec;
1515 s32 trigger_tstamp_nsec;
1516 s32 tstamp_sec;
1517 s32 tstamp_nsec;
1518 u32 appl_ptr;
1519 u32 hw_ptr;
1520 s32 delay;
1521 u32 avail;
1522 u32 avail_max;
1523 u32 overrange;
1524 snd_pcm_state_t suspended_state;
1525 u32 audio_tstamp_data;
1526 s32 audio_tstamp_sec;
1527 s32 audio_tstamp_nsec;
1528 s32 driver_tstamp_sec;
1529 s32 driver_tstamp_nsec;
1530 u32 audio_tstamp_accuracy;
1531 unsigned char reserved[52-4*sizeof(s32)];
1532};
1533
1534#define SNDRV_PCM_IOCTL_STATUS32 _IOR('A', 0x20, struct snd_pcm_status32)
1535#define SNDRV_PCM_IOCTL_STATUS_EXT32 _IOWR('A', 0x24, struct snd_pcm_status32)
1536
1537#endif
1538