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