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