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