cregit-Linux how code gets into the kernel

Release 4.12 include/sound/pcm.h

Directory: include/sound
#ifndef __SOUND_PCM_H

#define __SOUND_PCM_H

/*
 *  Digital Audio (PCM) abstract layer
 *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
 *                   Abramo Bagnara <abramo@alsa-project.org>
 *
 *
 *   This program is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program; if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 *
 */

#include <sound/asound.h>
#include <sound/memalloc.h>
#include <sound/minors.h>
#include <linux/poll.h>
#include <linux/mm.h>
#include <linux/bitops.h>
#include <linux/pm_qos.h>


#define snd_pcm_substream_chip(substream) ((substream)->private_data)

#define snd_pcm_chip(pcm) ((pcm)->private_data)

#if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
#include <sound/pcm_oss.h>
#endif

/*
 *  Hardware (lowlevel) section
 */


struct snd_pcm_hardware {
	
unsigned int info;		/* SNDRV_PCM_INFO_* */
	
u64 formats;			/* SNDRV_PCM_FMTBIT_* */
	
unsigned int rates;		/* SNDRV_PCM_RATE_* */
	
unsigned int rate_min;		/* min rate */
	
unsigned int rate_max;		/* max rate */
	
unsigned int channels_min;	/* min channels */
	
unsigned int channels_max;	/* max channels */
	
size_t buffer_bytes_max;	/* max buffer size */
	
size_t period_bytes_min;	/* min period size */
	
size_t period_bytes_max;	/* max period size */
	
unsigned int periods_min;	/* min # of periods */
	
unsigned int periods_max;	/* max # of periods */
	
size_t fifo_size;		/* fifo size in bytes */
};

struct snd_pcm_substream;

struct snd_pcm_audio_tstamp_config; /* definitions further down */
struct snd_pcm_audio_tstamp_report;


struct snd_pcm_ops {
	
int (*open)(struct snd_pcm_substream *substream);
	
int (*close)(struct snd_pcm_substream *substream);
	
int (*ioctl)(struct snd_pcm_substream * substream,
		     unsigned int cmd, void *arg);
	
int (*hw_params)(struct snd_pcm_substream *substream,
			 struct snd_pcm_hw_params *params);
	
int (*hw_free)(struct snd_pcm_substream *substream);
	
int (*prepare)(struct snd_pcm_substream *substream);
	
int (*trigger)(struct snd_pcm_substream *substream, int cmd);
	
snd_pcm_uframes_t (*pointer)(struct snd_pcm_substream *substream);
	
int (*get_time_info)(struct snd_pcm_substream *substream,
			struct timespec *system_ts, struct timespec *audio_ts,
			struct snd_pcm_audio_tstamp_config *audio_tstamp_config,
			struct snd_pcm_audio_tstamp_report *audio_tstamp_report);
	
int (*copy)(struct snd_pcm_substream *substream, int channel,
		    snd_pcm_uframes_t pos,
		    void __user *buf, snd_pcm_uframes_t count);
	
int (*silence)(struct snd_pcm_substream *substream, int channel, 
		       snd_pcm_uframes_t pos, snd_pcm_uframes_t count);
	
struct page *(*page)(struct snd_pcm_substream *substream,
			     unsigned long offset);
	
int (*mmap)(struct snd_pcm_substream *substream, struct vm_area_struct *vma);
	
int (*ack)(struct snd_pcm_substream *substream);
};

/*
 *
 */

#if defined(CONFIG_SND_DYNAMIC_MINORS)

#define SNDRV_PCM_DEVICES	(SNDRV_OS_MINORS-2)
#else

#define SNDRV_PCM_DEVICES	8
#endif


#define SNDRV_PCM_IOCTL1_RESET		0

#define SNDRV_PCM_IOCTL1_INFO		1

#define SNDRV_PCM_IOCTL1_CHANNEL_INFO	2

#define SNDRV_PCM_IOCTL1_GSTATE		3

#define SNDRV_PCM_IOCTL1_FIFO_SIZE	4


#define SNDRV_PCM_TRIGGER_STOP		0

#define SNDRV_PCM_TRIGGER_START		1

#define SNDRV_PCM_TRIGGER_PAUSE_PUSH	3

#define SNDRV_PCM_TRIGGER_PAUSE_RELEASE	4

#define SNDRV_PCM_TRIGGER_SUSPEND	5

#define SNDRV_PCM_TRIGGER_RESUME	6

#define SNDRV_PCM_TRIGGER_DRAIN		7


#define SNDRV_PCM_POS_XRUN		((snd_pcm_uframes_t)-1)

/* If you change this don't forget to change rates[] table in pcm_native.c */

#define SNDRV_PCM_RATE_5512		(1<<0)		
/* 5512Hz */

#define SNDRV_PCM_RATE_8000		(1<<1)		
/* 8000Hz */

#define SNDRV_PCM_RATE_11025		(1<<2)		
/* 11025Hz */

#define SNDRV_PCM_RATE_16000		(1<<3)		
/* 16000Hz */

#define SNDRV_PCM_RATE_22050		(1<<4)		
/* 22050Hz */

#define SNDRV_PCM_RATE_32000		(1<<5)		
/* 32000Hz */

#define SNDRV_PCM_RATE_44100		(1<<6)		
/* 44100Hz */

#define SNDRV_PCM_RATE_48000		(1<<7)		
/* 48000Hz */

#define SNDRV_PCM_RATE_64000		(1<<8)		
/* 64000Hz */

#define SNDRV_PCM_RATE_88200		(1<<9)		
/* 88200Hz */

#define SNDRV_PCM_RATE_96000		(1<<10)		
/* 96000Hz */

#define SNDRV_PCM_RATE_176400		(1<<11)		
/* 176400Hz */

#define SNDRV_PCM_RATE_192000		(1<<12)		
/* 192000Hz */


#define SNDRV_PCM_RATE_CONTINUOUS	(1<<30)		
/* continuous range */

#define SNDRV_PCM_RATE_KNOT		(1<<31)		
/* supports more non-continuos rates */


#define SNDRV_PCM_RATE_8000_44100	(SNDRV_PCM_RATE_8000|SNDRV_PCM_RATE_11025|\
                                         SNDRV_PCM_RATE_16000|SNDRV_PCM_RATE_22050|\
                                         SNDRV_PCM_RATE_32000|SNDRV_PCM_RATE_44100)

#define SNDRV_PCM_RATE_8000_48000	(SNDRV_PCM_RATE_8000_44100|SNDRV_PCM_RATE_48000)

#define SNDRV_PCM_RATE_8000_96000	(SNDRV_PCM_RATE_8000_48000|SNDRV_PCM_RATE_64000|\
                                         SNDRV_PCM_RATE_88200|SNDRV_PCM_RATE_96000)

#define SNDRV_PCM_RATE_8000_192000	(SNDRV_PCM_RATE_8000_96000|SNDRV_PCM_RATE_176400|\
                                         SNDRV_PCM_RATE_192000)

#define _SNDRV_PCM_FMTBIT(fmt)		(1ULL << (__force int)SNDRV_PCM_FORMAT_##fmt)

#define SNDRV_PCM_FMTBIT_S8		_SNDRV_PCM_FMTBIT(S8)

#define SNDRV_PCM_FMTBIT_U8		_SNDRV_PCM_FMTBIT(U8)

#define SNDRV_PCM_FMTBIT_S16_LE		_SNDRV_PCM_FMTBIT(S16_LE)

#define SNDRV_PCM_FMTBIT_S16_BE		_SNDRV_PCM_FMTBIT(S16_BE)

#define SNDRV_PCM_FMTBIT_U16_LE		_SNDRV_PCM_FMTBIT(U16_LE)

#define SNDRV_PCM_FMTBIT_U16_BE		_SNDRV_PCM_FMTBIT(U16_BE)

#define SNDRV_PCM_FMTBIT_S24_LE		_SNDRV_PCM_FMTBIT(S24_LE)

#define SNDRV_PCM_FMTBIT_S24_BE		_SNDRV_PCM_FMTBIT(S24_BE)

#define SNDRV_PCM_FMTBIT_U24_LE		_SNDRV_PCM_FMTBIT(U24_LE)

#define SNDRV_PCM_FMTBIT_U24_BE		_SNDRV_PCM_FMTBIT(U24_BE)

#define SNDRV_PCM_FMTBIT_S32_LE		_SNDRV_PCM_FMTBIT(S32_LE)

#define SNDRV_PCM_FMTBIT_S32_BE		_SNDRV_PCM_FMTBIT(S32_BE)

#define SNDRV_PCM_FMTBIT_U32_LE		_SNDRV_PCM_FMTBIT(U32_LE)

#define SNDRV_PCM_FMTBIT_U32_BE		_SNDRV_PCM_FMTBIT(U32_BE)

#define SNDRV_PCM_FMTBIT_FLOAT_LE	_SNDRV_PCM_FMTBIT(FLOAT_LE)

#define SNDRV_PCM_FMTBIT_FLOAT_BE	_SNDRV_PCM_FMTBIT(FLOAT_BE)

#define SNDRV_PCM_FMTBIT_FLOAT64_LE	_SNDRV_PCM_FMTBIT(FLOAT64_LE)

#define SNDRV_PCM_FMTBIT_FLOAT64_BE	_SNDRV_PCM_FMTBIT(FLOAT64_BE)

#define SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE _SNDRV_PCM_FMTBIT(IEC958_SUBFRAME_LE)

#define SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_BE _SNDRV_PCM_FMTBIT(IEC958_SUBFRAME_BE)

#define SNDRV_PCM_FMTBIT_MU_LAW		_SNDRV_PCM_FMTBIT(MU_LAW)

#define SNDRV_PCM_FMTBIT_A_LAW		_SNDRV_PCM_FMTBIT(A_LAW)

#define SNDRV_PCM_FMTBIT_IMA_ADPCM	_SNDRV_PCM_FMTBIT(IMA_ADPCM)

#define SNDRV_PCM_FMTBIT_MPEG		_SNDRV_PCM_FMTBIT(MPEG)

#define SNDRV_PCM_FMTBIT_GSM		_SNDRV_PCM_FMTBIT(GSM)

#define SNDRV_PCM_FMTBIT_SPECIAL	_SNDRV_PCM_FMTBIT(SPECIAL)

#define SNDRV_PCM_FMTBIT_S24_3LE	_SNDRV_PCM_FMTBIT(S24_3LE)

#define SNDRV_PCM_FMTBIT_U24_3LE	_SNDRV_PCM_FMTBIT(U24_3LE)

#define SNDRV_PCM_FMTBIT_S24_3BE	_SNDRV_PCM_FMTBIT(S24_3BE)

#define SNDRV_PCM_FMTBIT_U24_3BE	_SNDRV_PCM_FMTBIT(U24_3BE)

#define SNDRV_PCM_FMTBIT_S20_3LE	_SNDRV_PCM_FMTBIT(S20_3LE)

#define SNDRV_PCM_FMTBIT_U20_3LE	_SNDRV_PCM_FMTBIT(U20_3LE)

#define SNDRV_PCM_FMTBIT_S20_3BE	_SNDRV_PCM_FMTBIT(S20_3BE)

#define SNDRV_PCM_FMTBIT_U20_3BE	_SNDRV_PCM_FMTBIT(U20_3BE)

#define SNDRV_PCM_FMTBIT_S18_3LE	_SNDRV_PCM_FMTBIT(S18_3LE)

#define SNDRV_PCM_FMTBIT_U18_3LE	_SNDRV_PCM_FMTBIT(U18_3LE)

#define SNDRV_PCM_FMTBIT_S18_3BE	_SNDRV_PCM_FMTBIT(S18_3BE)

#define SNDRV_PCM_FMTBIT_U18_3BE	_SNDRV_PCM_FMTBIT(U18_3BE)

#define SNDRV_PCM_FMTBIT_G723_24	_SNDRV_PCM_FMTBIT(G723_24)

#define SNDRV_PCM_FMTBIT_G723_24_1B	_SNDRV_PCM_FMTBIT(G723_24_1B)

#define SNDRV_PCM_FMTBIT_G723_40	_SNDRV_PCM_FMTBIT(G723_40)

#define SNDRV_PCM_FMTBIT_G723_40_1B	_SNDRV_PCM_FMTBIT(G723_40_1B)

#define SNDRV_PCM_FMTBIT_DSD_U8		_SNDRV_PCM_FMTBIT(DSD_U8)

#define SNDRV_PCM_FMTBIT_DSD_U16_LE	_SNDRV_PCM_FMTBIT(DSD_U16_LE)

#define SNDRV_PCM_FMTBIT_DSD_U32_LE	_SNDRV_PCM_FMTBIT(DSD_U32_LE)

#define SNDRV_PCM_FMTBIT_DSD_U16_BE	_SNDRV_PCM_FMTBIT(DSD_U16_BE)

#define SNDRV_PCM_FMTBIT_DSD_U32_BE	_SNDRV_PCM_FMTBIT(DSD_U32_BE)

#ifdef SNDRV_LITTLE_ENDIAN

#define SNDRV_PCM_FMTBIT_S16		SNDRV_PCM_FMTBIT_S16_LE

#define SNDRV_PCM_FMTBIT_U16		SNDRV_PCM_FMTBIT_U16_LE

#define SNDRV_PCM_FMTBIT_S24		SNDRV_PCM_FMTBIT_S24_LE

#define SNDRV_PCM_FMTBIT_U24		SNDRV_PCM_FMTBIT_U24_LE

#define SNDRV_PCM_FMTBIT_S32		SNDRV_PCM_FMTBIT_S32_LE

#define SNDRV_PCM_FMTBIT_U32		SNDRV_PCM_FMTBIT_U32_LE

#define SNDRV_PCM_FMTBIT_FLOAT		SNDRV_PCM_FMTBIT_FLOAT_LE

#define SNDRV_PCM_FMTBIT_FLOAT64	SNDRV_PCM_FMTBIT_FLOAT64_LE

#define SNDRV_PCM_FMTBIT_IEC958_SUBFRAME SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE
#endif
#ifdef SNDRV_BIG_ENDIAN

#define SNDRV_PCM_FMTBIT_S16		SNDRV_PCM_FMTBIT_S16_BE

#define SNDRV_PCM_FMTBIT_U16		SNDRV_PCM_FMTBIT_U16_BE

#define SNDRV_PCM_FMTBIT_S24		SNDRV_PCM_FMTBIT_S24_BE

#define SNDRV_PCM_FMTBIT_U24		SNDRV_PCM_FMTBIT_U24_BE

#define SNDRV_PCM_FMTBIT_S32		SNDRV_PCM_FMTBIT_S32_BE

#define SNDRV_PCM_FMTBIT_U32		SNDRV_PCM_FMTBIT_U32_BE

#define SNDRV_PCM_FMTBIT_FLOAT		SNDRV_PCM_FMTBIT_FLOAT_BE

#define SNDRV_PCM_FMTBIT_FLOAT64	SNDRV_PCM_FMTBIT_FLOAT64_BE

#define SNDRV_PCM_FMTBIT_IEC958_SUBFRAME SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_BE
#endif


struct snd_pcm_file {
	
struct snd_pcm_substream *substream;
	
int no_compat_mmap;
};

struct snd_pcm_hw_rule;

typedef int (*snd_pcm_hw_rule_func_t)(struct snd_pcm_hw_params *params,
				      struct snd_pcm_hw_rule *rule);


struct snd_pcm_hw_rule {
	
unsigned int cond;
	
int var;
	
int deps[4];

	
snd_pcm_hw_rule_func_t func;
	
void *private;
};


struct snd_pcm_hw_constraints {
	
struct snd_mask masks[SNDRV_PCM_HW_PARAM_LAST_MASK - 
			 SNDRV_PCM_HW_PARAM_FIRST_MASK + 1];
	
struct snd_interval intervals[SNDRV_PCM_HW_PARAM_LAST_INTERVAL -
			     SNDRV_PCM_HW_PARAM_FIRST_INTERVAL + 1];
	
unsigned int rules_num;
	
unsigned int rules_all;
	
struct snd_pcm_hw_rule *rules;
};




static inline struct snd_mask *constrs_mask(struct snd_pcm_hw_constraints *constrs,
					    snd_pcm_hw_param_t var)
{
	return &constrs->masks[var - SNDRV_PCM_HW_PARAM_FIRST_MASK];
}


Contributors
PersonTokensPropCommitsCommitProp
Jaroslav Kysela2485.71%150.00%


Takashi Iwai414.29%150.00%


Total28100.00%2100.00%






static inline struct snd_interval *constrs_interval(struct snd_pcm_hw_constraints *constrs,
						    snd_pcm_hw_param_t var)
{
	return &constrs->intervals[var - SNDRV_PCM_HW_PARAM_FIRST_INTERVAL];
}


Contributors
PersonTokensPropCommitsCommitProp
Jaroslav Kysela2485.71%150.00%


Takashi Iwai414.29%150.00%


Total28100.00%2100.00%




struct snd_ratnum {
	
unsigned int num;
	


unsigned int den_min, den_max, den_step;
};


struct snd_ratden {
	


unsigned int num_min, num_max, num_step;
	
unsigned int den;
};


struct snd_pcm_hw_constraint_ratnums {
	
int nrats;
	
const struct snd_ratnum *rats;
};


struct snd_pcm_hw_constraint_ratdens {
	
int nrats;
	
const struct snd_ratden *rats;
};


struct snd_pcm_hw_constraint_list {
	
const unsigned int *list;
	
unsigned int count;
	
unsigned int mask;
};


struct snd_pcm_hw_constraint_ranges {
	
unsigned int count;
	
const struct snd_interval *ranges;
	
unsigned int mask;
};

/*
 * userspace-provided audio timestamp config to kernel,
 * structure is for internal use only and filled with dedicated unpack routine
 */

struct snd_pcm_audio_tstamp_config {
	/* 5 of max 16 bits used */
	
u32 type_requested:4;
	
u32 report_delay:1; /* add total delay to A/D or D/A */
};




static inline void snd_pcm_unpack_audio_tstamp_config(__u32 data,
						struct snd_pcm_audio_tstamp_config *config)
{
	config->type_requested = data & 0xF;
	config->report_delay = (data >> 4) & 1;
}


Contributors
PersonTokensPropCommitsCommitProp
Pierre-Louis Bossart35100.00%1100.00%


Total35100.00%1100.00%



/*
 * kernel-provided audio timestamp report to user-space
 * structure is for internal use only and read by dedicated pack routine
 */

struct snd_pcm_audio_tstamp_report {
	/* 6 of max 16 bits used for bit-fields */

	/* for backwards compatibility */
	
u32 valid:1;

	/* actual type if hardware could not support requested timestamp */
	
u32 actual_type:4;

	/* accuracy represented in ns units */
	
u32 accuracy_report:1; /* 0 if accuracy unknown, 1 if accuracy field is valid */
	
u32 accuracy; /* up to 4.29s, will be packed in separate field  */
};




static inline void snd_pcm_pack_audio_tstamp_report(__u32 *data, __u32 *accuracy,
						const struct snd_pcm_audio_tstamp_report *report)
{
	u32 tmp;

	tmp = report->accuracy_report;
	tmp <<= 4;
	tmp |= report->actual_type;
	tmp <<= 1;
	tmp |= report->valid;

	*data &= 0xffff; /* zero-clear MSBs */
	*data |= (tmp << 16);
	*accuracy = report->accuracy;
}



Contributors
PersonTokensPropCommitsCommitProp
Pierre-Louis Bossart72100.00%1100.00%


Total72100.00%1100.00%




struct snd_pcm_runtime {
	/* -- Status -- */
	
struct snd_pcm_substream *trigger_master;
	
struct timespec trigger_tstamp;	/* trigger timestamp */
	
bool trigger_tstamp_latched;     /* trigger timestamp latched in low-level driver/hardware */
	
int overrange;
	
snd_pcm_uframes_t avail_max;
	
snd_pcm_uframes_t hw_ptr_base;	/* Position at buffer restart */
	
snd_pcm_uframes_t hw_ptr_interrupt; /* Position at interrupt time */
	
unsigned long hw_ptr_jiffies;	/* Time when hw_ptr is updated */
	
unsigned long hw_ptr_buffer_jiffies; /* buffer time in jiffies */
	
snd_pcm_sframes_t delay;	/* extra delay; typically FIFO size */
	
u64 hw_ptr_wrap;                /* offset for hw_ptr due to boundary wrap-around */

	/* -- HW params -- */
	
snd_pcm_access_t access;	/* access mode */
	
snd_pcm_format_t format;	/* SNDRV_PCM_FORMAT_* */
	
snd_pcm_subformat_t subformat;	/* subformat */
	
unsigned int rate;		/* rate in Hz */
	
unsigned int channels;		/* channels */
	
snd_pcm_uframes_t period_size;	/* period size */
	
unsigned int periods;		/* periods */
	
snd_pcm_uframes_t buffer_size;	/* buffer size */
	
snd_pcm_uframes_t min_align;	/* Min alignment for the format */
	
size_t byte_align;
	
unsigned int frame_bits;
	
unsigned int sample_bits;
	
unsigned int info;
	
unsigned int rate_num;
	
unsigned int rate_den;
	
unsigned int no_period_wakeup: 1;

	/* -- SW params -- */
	
int tstamp_mode;		/* mmap timestamp is updated */
  	
unsigned int period_step;
	
snd_pcm_uframes_t start_threshold;
	
snd_pcm_uframes_t stop_threshold;
	
snd_pcm_uframes_t silence_threshold; /* Silence filling happens when
                                                noise is nearest than this */
	
snd_pcm_uframes_t silence_size;	/* Silence filling size */
	
snd_pcm_uframes_t boundary;	/* pointers wrap point */

	
snd_pcm_uframes_t silence_start; /* starting pointer to silence area */
	
snd_pcm_uframes_t silence_filled; /* size filled with silence */

	
union snd_pcm_sync_id sync;	/* hardware synchronization ID */

	/* -- mmap -- */
	
struct snd_pcm_mmap_status *status;
	
struct snd_pcm_mmap_control *control;

	/* -- locking / scheduling -- */
	
snd_pcm_uframes_t twake; 	/* do transfer (!poll) wakeup if non-zero */
	
wait_queue_head_t sleep;	/* poll sleep */
	
wait_queue_head_t tsleep;	/* transfer sleep */
	
struct fasync_struct *fasync;

	/* -- private section -- */
	
void *private_data;
	
void (*private_free)(struct snd_pcm_runtime *runtime);

	/* -- hardware description -- */
	
struct snd_pcm_hardware hw;
	
struct snd_pcm_hw_constraints hw_constraints;

	/* -- timer -- */
	
unsigned int timer_resolution;	/* timer resolution */
	
int tstamp_type;		/* timestamp type */

	/* -- DMA -- */           
	
unsigned char *dma_area;	/* DMA area */
	
dma_addr_t dma_addr;		/* physical bus address (not accessible from main CPU) */
	
size_t dma_bytes;		/* size of DMA area */

	
struct snd_dma_buffer *dma_buffer_p;	/* allocated buffer */

	/* -- audio timestamp config -- */
	
struct snd_pcm_audio_tstamp_config audio_tstamp_config;
	
struct snd_pcm_audio_tstamp_report audio_tstamp_report;
	
struct timespec driver_tstamp;

#if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
	/* -- OSS things -- */
	
struct snd_pcm_oss_runtime oss;
#endif
};


struct snd_pcm_group {		/* keep linked substreams */
	
spinlock_t lock;
	
struct mutex mutex;
	
struct list_head substreams;
	
int count;
};

struct pid;


struct snd_pcm_substream {
	
struct snd_pcm *pcm;
	
struct snd_pcm_str *pstr;
	
void *private_data;		/* copied from pcm->private_data */
	
int number;
	
char name[32];			/* substream name */
	
int stream;			/* stream (direction) */
	
struct pm_qos_request latency_pm_qos_req; /* pm_qos request */
	
size_t buffer_bytes_max;	/* limit ring buffer size */
	
struct snd_dma_buffer dma_buffer;
	
size_t dma_max;
	/* -- hardware operations -- */
	
const struct snd_pcm_ops *ops;
	/* -- runtime information -- */
	
struct snd_pcm_runtime *runtime;
        /* -- timer section -- */
	
struct snd_timer *timer;		/* timer */
	
unsigned timer_running: 1;	/* time is running */
	/* -- next substream -- */
	
struct snd_pcm_substream *next;
	/* -- linked substreams -- */
	
struct list_head link_list;	/* linked list member */
	
struct snd_pcm_group self_group;	/* fake group for non linked substream (with substream lock inside) */
	
struct snd_pcm_group *group;		/* pointer to current group */
	/* -- assigned files -- */
	
void *file;
	
int ref_count;
	
atomic_t mmap_count;
	
unsigned int f_flags;
	
void (*pcm_release)(struct snd_pcm_substream *);
	
struct pid *pid;
#if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
	/* -- OSS things -- */
	
struct snd_pcm_oss_substream oss;
#endif
#ifdef CONFIG_SND_VERBOSE_PROCFS
	
struct snd_info_entry *proc_root;
	
struct snd_info_entry *proc_info_entry;
	
struct snd_info_entry *proc_hw_params_entry;
	
struct snd_info_entry *proc_sw_params_entry;
	
struct snd_info_entry *proc_status_entry;
	
struct snd_info_entry *proc_prealloc_entry;
	
struct snd_info_entry *proc_prealloc_max_entry;
#ifdef CONFIG_SND_PCM_XRUN_DEBUG
	
struct snd_info_entry *proc_xrun_injection_entry;
#endif
#endif /* CONFIG_SND_VERBOSE_PROCFS */
	/* misc flags */
	
unsigned int hw_opened: 1;
};


#define SUBSTREAM_BUSY(substream) ((substream)->ref_count > 0)



struct snd_pcm_str {
	
int stream;				/* stream (direction) */
	
struct snd_pcm *pcm;
	/* -- substreams -- */
	
unsigned int substream_count;
	
unsigned int substream_opened;
	
struct snd_pcm_substream *substream;
#if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
	/* -- OSS things -- */
	
struct snd_pcm_oss_stream oss;
#endif
#ifdef CONFIG_SND_VERBOSE_PROCFS
	
struct snd_info_entry *proc_root;
	
struct snd_info_entry *proc_info_entry;
#ifdef CONFIG_SND_PCM_XRUN_DEBUG
	
unsigned int xrun_debug;	/* 0 = disabled, 1 = verbose, 2 = stacktrace */
	
struct snd_info_entry *proc_xrun_debug_entry;
#endif
#endif
	
struct snd_kcontrol *chmap_kctl; /* channel-mapping controls */
	
struct device dev;
};


struct snd_pcm {
	
struct snd_card *card;
	
struct list_head list;
	
int device; /* device number */
	
unsigned int info_flags;
	
unsigned short dev_class;
	
unsigned short dev_subclass;
	
char id[64];
	
char name[80];
	
struct snd_pcm_str streams[2];
	
struct mutex open_mutex;
	
wait_queue_head_t open_wait;
	
void *private_data;
	
void (*private_free) (struct snd_pcm *pcm);
	
bool internal; /* pcm is for internal use only */
	
bool nonatomic; /* whole PCM operations are in non-atomic context */
#if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
	
struct snd_pcm_oss oss;
#endif
};


struct snd_pcm_notify {
	
int (*n_register) (struct snd_pcm * pcm);
	
int (*n_disconnect) (struct snd_pcm * pcm);
	
int (*n_unregister) (struct snd_pcm * pcm);
	
struct list_head list;
};

/*
 *  Registering
 */

extern const struct file_operations snd_pcm_f_ops[2];

int snd_pcm_new(struct snd_card *card, const char *id, int device,
		int playback_count, int capture_count,
		struct snd_pcm **rpcm);
int snd_pcm_new_internal(struct snd_card *card, const char *id, int device,
		int playback_count, int capture_count,
		struct snd_pcm **rpcm);
int snd_pcm_new_stream(struct snd_pcm *pcm, int stream, int substream_count);

int snd_pcm_notify(struct snd_pcm_notify *notify, int nfree);

/*
 *  Native I/O
 */

int snd_pcm_info(struct snd_pcm_substream *substream, struct snd_pcm_info *info);
int snd_pcm_info_user(struct snd_pcm_substream *substream,
		      struct snd_pcm_info __user *info);
int snd_pcm_status(struct snd_pcm_substream *substream,
		   struct snd_pcm_status *status);
int snd_pcm_start(struct snd_pcm_substream *substream);
int snd_pcm_stop(struct snd_pcm_substream *substream, snd_pcm_state_t status);
int snd_pcm_drain_done(struct snd_pcm_substream *substream);
int snd_pcm_stop_xrun(struct snd_pcm_substream *substream);
#ifdef CONFIG_PM
int snd_pcm_suspend(struct snd_pcm_substream *substream);
int snd_pcm_suspend_all(struct snd_pcm *pcm);
#else



static inline int snd_pcm_suspend(struct snd_pcm_substream *substream)
{
	return 0;
}

Contributors
PersonTokensPropCommitsCommitProp
Takashi Iwai15100.00%1100.00%


Total15100.00%1100.00%






static inline int snd_pcm_suspend_all(struct snd_pcm *pcm)
{
	return 0;
}

Contributors
PersonTokensPropCommitsCommitProp
Takashi Iwai15100.00%1100.00%


Total15100.00%1100.00%



#endif
int snd_pcm_kernel_ioctl(struct snd_pcm_substream *substream, unsigned int cmd, void *arg);
int snd_pcm_open_substream(struct snd_pcm *pcm, int stream, struct file *file,
			   struct snd_pcm_substream **rsubstream);
void snd_pcm_release_substream(struct snd_pcm_substream *substream);
int snd_pcm_attach_substream(struct snd_pcm *pcm, int stream, struct file *file,
			     struct snd_pcm_substream **rsubstream);
void snd_pcm_detach_substream(struct snd_pcm_substream *substream);
int snd_pcm_mmap_data(struct snd_pcm_substream *substream, struct file *file, struct vm_area_struct *area);


#ifdef CONFIG_SND_DEBUG
void snd_pcm_debug_name(struct snd_pcm_substream *substream,
			   char *name, size_t len);
#else


static inline void

snd_pcm_debug_name(struct snd_pcm_substream *substream, char *buf, size_t size)
{
	*buf = 0;
}

Contributors
PersonTokensPropCommitsCommitProp
Eliot Blennerhassett24100.00%1100.00%


Total24100.00%1100.00%



#endif

/*
 *  PCM library
 */

/**
 * snd_pcm_stream_linked - Check whether the substream is linked with others
 * @substream: substream to check
 *
 * Returns true if the given substream is being linked with others.
 */



static inline int snd_pcm_stream_linked(struct snd_pcm_substream *substream)
{
	return substream->group != &substream->self_group;
}


Contributors
PersonTokensPropCommitsCommitProp
Jaroslav Kysela2090.91%150.00%


Takashi Iwai29.09%150.00%


Total22100.00%2100.00%



void snd_pcm_stream_lock(struct snd_pcm_substream *substream);
void snd_pcm_stream_unlock(struct snd_pcm_substream *substream);
void snd_pcm_stream_lock_irq(struct snd_pcm_substream *substream);
void snd_pcm_stream_unlock_irq(struct snd_pcm_substream *substream);
unsigned long _snd_pcm_stream_lock_irqsave(struct snd_pcm_substream *substream);

/**
 * snd_pcm_stream_lock_irqsave - Lock the PCM stream
 * @substream: PCM substream
 * @flags: irq flags
 *
 * This locks the PCM stream like snd_pcm_stream_lock() but with the local
 * IRQ (only when nonatomic is false).  In nonatomic case, this is identical
 * as snd_pcm_stream_lock().
 */

#define snd_pcm_stream_lock_irqsave(substream, flags)		 \
	do {                                                     \
                typecheck(unsigned long, flags);                 \
                flags = _snd_pcm_stream_lock_irqsave(substream); \
        } while (0)
void snd_pcm_stream_unlock_irqrestore(struct