linux/include/sound/pcm.h
<<
>>
Prefs
   1#ifndef __SOUND_PCM_H
   2#define __SOUND_PCM_H
   3
   4/*
   5 *  Digital Audio (PCM) abstract layer
   6 *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
   7 *                   Abramo Bagnara <abramo@alsa-project.org>
   8 *
   9 *
  10 *   This program is free software; you can redistribute it and/or modify
  11 *   it under the terms of the GNU General Public License as published by
  12 *   the Free Software Foundation; either version 2 of the License, or
  13 *   (at your option) any later version.
  14 *
  15 *   This program is distributed in the hope that it will be useful,
  16 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 *   GNU General Public License for more details.
  19 *
  20 *   You should have received a copy of the GNU General Public License
  21 *   along with this program; if not, write to the Free Software
  22 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  23 *
  24 */
  25
  26#include <sound/asound.h>
  27#include <sound/memalloc.h>
  28#include <sound/minors.h>
  29#include <linux/poll.h>
  30#include <linux/mm.h>
  31#include <linux/bitops.h>
  32#include <linux/pm_qos.h>
  33
  34#define snd_pcm_substream_chip(substream) ((substream)->private_data)
  35#define snd_pcm_chip(pcm) ((pcm)->private_data)
  36
  37#if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
  38#include <sound/pcm_oss.h>
  39#endif
  40
  41/*
  42 *  Hardware (lowlevel) section
  43 */
  44
  45struct snd_pcm_hardware {
  46        unsigned int info;              /* SNDRV_PCM_INFO_* */
  47        u64 formats;                    /* SNDRV_PCM_FMTBIT_* */
  48        unsigned int rates;             /* SNDRV_PCM_RATE_* */
  49        unsigned int rate_min;          /* min rate */
  50        unsigned int rate_max;          /* max rate */
  51        unsigned int channels_min;      /* min channels */
  52        unsigned int channels_max;      /* max channels */
  53        size_t buffer_bytes_max;        /* max buffer size */
  54        size_t period_bytes_min;        /* min period size */
  55        size_t period_bytes_max;        /* max period size */
  56        unsigned int periods_min;       /* min # of periods */
  57        unsigned int periods_max;       /* max # of periods */
  58        size_t fifo_size;               /* fifo size in bytes */
  59};
  60
  61struct snd_pcm_substream;
  62
  63struct snd_pcm_ops {
  64        int (*open)(struct snd_pcm_substream *substream);
  65        int (*close)(struct snd_pcm_substream *substream);
  66        int (*ioctl)(struct snd_pcm_substream * substream,
  67                     unsigned int cmd, void *arg);
  68        int (*hw_params)(struct snd_pcm_substream *substream,
  69                         struct snd_pcm_hw_params *params);
  70        int (*hw_free)(struct snd_pcm_substream *substream);
  71        int (*prepare)(struct snd_pcm_substream *substream);
  72        int (*trigger)(struct snd_pcm_substream *substream, int cmd);
  73        snd_pcm_uframes_t (*pointer)(struct snd_pcm_substream *substream);
  74        int (*wall_clock)(struct snd_pcm_substream *substream,
  75                          struct timespec *audio_ts);
  76        int (*copy)(struct snd_pcm_substream *substream, int channel,
  77                    snd_pcm_uframes_t pos,
  78                    void __user *buf, snd_pcm_uframes_t count);
  79        int (*silence)(struct snd_pcm_substream *substream, int channel, 
  80                       snd_pcm_uframes_t pos, snd_pcm_uframes_t count);
  81        struct page *(*page)(struct snd_pcm_substream *substream,
  82                             unsigned long offset);
  83        int (*mmap)(struct snd_pcm_substream *substream, struct vm_area_struct *vma);
  84        int (*ack)(struct snd_pcm_substream *substream);
  85};
  86
  87/*
  88 *
  89 */
  90
  91#if defined(CONFIG_SND_DYNAMIC_MINORS)
  92#define SNDRV_PCM_DEVICES       (SNDRV_OS_MINORS-2)
  93#else
  94#define SNDRV_PCM_DEVICES       8
  95#endif
  96
  97#define SNDRV_PCM_IOCTL1_FALSE          ((void *)0)
  98#define SNDRV_PCM_IOCTL1_TRUE           ((void *)1)
  99
 100#define SNDRV_PCM_IOCTL1_RESET          0
 101#define SNDRV_PCM_IOCTL1_INFO           1
 102#define SNDRV_PCM_IOCTL1_CHANNEL_INFO   2
 103#define SNDRV_PCM_IOCTL1_GSTATE         3
 104#define SNDRV_PCM_IOCTL1_FIFO_SIZE      4
 105
 106#define SNDRV_PCM_TRIGGER_STOP          0
 107#define SNDRV_PCM_TRIGGER_START         1
 108#define SNDRV_PCM_TRIGGER_PAUSE_PUSH    3
 109#define SNDRV_PCM_TRIGGER_PAUSE_RELEASE 4
 110#define SNDRV_PCM_TRIGGER_SUSPEND       5
 111#define SNDRV_PCM_TRIGGER_RESUME        6
 112
 113#define SNDRV_PCM_POS_XRUN              ((snd_pcm_uframes_t)-1)
 114
 115/* If you change this don't forget to change rates[] table in pcm_native.c */
 116#define SNDRV_PCM_RATE_5512             (1<<0)          /* 5512Hz */
 117#define SNDRV_PCM_RATE_8000             (1<<1)          /* 8000Hz */
 118#define SNDRV_PCM_RATE_11025            (1<<2)          /* 11025Hz */
 119#define SNDRV_PCM_RATE_16000            (1<<3)          /* 16000Hz */
 120#define SNDRV_PCM_RATE_22050            (1<<4)          /* 22050Hz */
 121#define SNDRV_PCM_RATE_32000            (1<<5)          /* 32000Hz */
 122#define SNDRV_PCM_RATE_44100            (1<<6)          /* 44100Hz */
 123#define SNDRV_PCM_RATE_48000            (1<<7)          /* 48000Hz */
 124#define SNDRV_PCM_RATE_64000            (1<<8)          /* 64000Hz */
 125#define SNDRV_PCM_RATE_88200            (1<<9)          /* 88200Hz */
 126#define SNDRV_PCM_RATE_96000            (1<<10)         /* 96000Hz */
 127#define SNDRV_PCM_RATE_176400           (1<<11)         /* 176400Hz */
 128#define SNDRV_PCM_RATE_192000           (1<<12)         /* 192000Hz */
 129
 130#define SNDRV_PCM_RATE_CONTINUOUS       (1<<30)         /* continuous range */
 131#define SNDRV_PCM_RATE_KNOT             (1<<31)         /* supports more non-continuos rates */
 132
 133#define SNDRV_PCM_RATE_8000_44100       (SNDRV_PCM_RATE_8000|SNDRV_PCM_RATE_11025|\
 134                                         SNDRV_PCM_RATE_16000|SNDRV_PCM_RATE_22050|\
 135                                         SNDRV_PCM_RATE_32000|SNDRV_PCM_RATE_44100)
 136#define SNDRV_PCM_RATE_8000_48000       (SNDRV_PCM_RATE_8000_44100|SNDRV_PCM_RATE_48000)
 137#define SNDRV_PCM_RATE_8000_96000       (SNDRV_PCM_RATE_8000_48000|SNDRV_PCM_RATE_64000|\
 138                                         SNDRV_PCM_RATE_88200|SNDRV_PCM_RATE_96000)
 139#define SNDRV_PCM_RATE_8000_192000      (SNDRV_PCM_RATE_8000_96000|SNDRV_PCM_RATE_176400|\
 140                                         SNDRV_PCM_RATE_192000)
 141#define _SNDRV_PCM_FMTBIT(fmt)          (1ULL << (__force int)SNDRV_PCM_FORMAT_##fmt)
 142#define SNDRV_PCM_FMTBIT_S8             _SNDRV_PCM_FMTBIT(S8)
 143#define SNDRV_PCM_FMTBIT_U8             _SNDRV_PCM_FMTBIT(U8)
 144#define SNDRV_PCM_FMTBIT_S16_LE         _SNDRV_PCM_FMTBIT(S16_LE)
 145#define SNDRV_PCM_FMTBIT_S16_BE         _SNDRV_PCM_FMTBIT(S16_BE)
 146#define SNDRV_PCM_FMTBIT_U16_LE         _SNDRV_PCM_FMTBIT(U16_LE)
 147#define SNDRV_PCM_FMTBIT_U16_BE         _SNDRV_PCM_FMTBIT(U16_BE)
 148#define SNDRV_PCM_FMTBIT_S24_LE         _SNDRV_PCM_FMTBIT(S24_LE)
 149#define SNDRV_PCM_FMTBIT_S24_BE         _SNDRV_PCM_FMTBIT(S24_BE)
 150#define SNDRV_PCM_FMTBIT_U24_LE         _SNDRV_PCM_FMTBIT(U24_LE)
 151#define SNDRV_PCM_FMTBIT_U24_BE         _SNDRV_PCM_FMTBIT(U24_BE)
 152#define SNDRV_PCM_FMTBIT_S32_LE         _SNDRV_PCM_FMTBIT(S32_LE)
 153#define SNDRV_PCM_FMTBIT_S32_BE         _SNDRV_PCM_FMTBIT(S32_BE)
 154#define SNDRV_PCM_FMTBIT_U32_LE         _SNDRV_PCM_FMTBIT(U32_LE)
 155#define SNDRV_PCM_FMTBIT_U32_BE         _SNDRV_PCM_FMTBIT(U32_BE)
 156#define SNDRV_PCM_FMTBIT_FLOAT_LE       _SNDRV_PCM_FMTBIT(FLOAT_LE)
 157#define SNDRV_PCM_FMTBIT_FLOAT_BE       _SNDRV_PCM_FMTBIT(FLOAT_BE)
 158#define SNDRV_PCM_FMTBIT_FLOAT64_LE     _SNDRV_PCM_FMTBIT(FLOAT64_LE)
 159#define SNDRV_PCM_FMTBIT_FLOAT64_BE     _SNDRV_PCM_FMTBIT(FLOAT64_BE)
 160#define SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE _SNDRV_PCM_FMTBIT(IEC958_SUBFRAME_LE)
 161#define SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_BE _SNDRV_PCM_FMTBIT(IEC958_SUBFRAME_BE)
 162#define SNDRV_PCM_FMTBIT_MU_LAW         _SNDRV_PCM_FMTBIT(MU_LAW)
 163#define SNDRV_PCM_FMTBIT_A_LAW          _SNDRV_PCM_FMTBIT(A_LAW)
 164#define SNDRV_PCM_FMTBIT_IMA_ADPCM      _SNDRV_PCM_FMTBIT(IMA_ADPCM)
 165#define SNDRV_PCM_FMTBIT_MPEG           _SNDRV_PCM_FMTBIT(MPEG)
 166#define SNDRV_PCM_FMTBIT_GSM            _SNDRV_PCM_FMTBIT(GSM)
 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
 185#ifdef SNDRV_LITTLE_ENDIAN
 186#define SNDRV_PCM_FMTBIT_S16            SNDRV_PCM_FMTBIT_S16_LE
 187#define SNDRV_PCM_FMTBIT_U16            SNDRV_PCM_FMTBIT_U16_LE
 188#define SNDRV_PCM_FMTBIT_S24            SNDRV_PCM_FMTBIT_S24_LE
 189#define SNDRV_PCM_FMTBIT_U24            SNDRV_PCM_FMTBIT_U24_LE
 190#define SNDRV_PCM_FMTBIT_S32            SNDRV_PCM_FMTBIT_S32_LE
 191#define SNDRV_PCM_FMTBIT_U32            SNDRV_PCM_FMTBIT_U32_LE
 192#define SNDRV_PCM_FMTBIT_FLOAT          SNDRV_PCM_FMTBIT_FLOAT_LE
 193#define SNDRV_PCM_FMTBIT_FLOAT64        SNDRV_PCM_FMTBIT_FLOAT64_LE
 194#define SNDRV_PCM_FMTBIT_IEC958_SUBFRAME SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE
 195#endif
 196#ifdef SNDRV_BIG_ENDIAN
 197#define SNDRV_PCM_FMTBIT_S16            SNDRV_PCM_FMTBIT_S16_BE
 198#define SNDRV_PCM_FMTBIT_U16            SNDRV_PCM_FMTBIT_U16_BE
 199#define SNDRV_PCM_FMTBIT_S24            SNDRV_PCM_FMTBIT_S24_BE
 200#define SNDRV_PCM_FMTBIT_U24            SNDRV_PCM_FMTBIT_U24_BE
 201#define SNDRV_PCM_FMTBIT_S32            SNDRV_PCM_FMTBIT_S32_BE
 202#define SNDRV_PCM_FMTBIT_U32            SNDRV_PCM_FMTBIT_U32_BE
 203#define SNDRV_PCM_FMTBIT_FLOAT          SNDRV_PCM_FMTBIT_FLOAT_BE
 204#define SNDRV_PCM_FMTBIT_FLOAT64        SNDRV_PCM_FMTBIT_FLOAT64_BE
 205#define SNDRV_PCM_FMTBIT_IEC958_SUBFRAME SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_BE
 206#endif
 207
 208struct snd_pcm_file {
 209        struct snd_pcm_substream *substream;
 210        int no_compat_mmap;
 211};
 212
 213struct snd_pcm_hw_rule;
 214typedef int (*snd_pcm_hw_rule_func_t)(struct snd_pcm_hw_params *params,
 215                                      struct snd_pcm_hw_rule *rule);
 216
 217struct snd_pcm_hw_rule {
 218        unsigned int cond;
 219        snd_pcm_hw_rule_func_t func;
 220        int var;
 221        int deps[4];
 222        void *private;
 223};
 224
 225struct snd_pcm_hw_constraints {
 226        struct snd_mask masks[SNDRV_PCM_HW_PARAM_LAST_MASK - 
 227                         SNDRV_PCM_HW_PARAM_FIRST_MASK + 1];
 228        struct snd_interval intervals[SNDRV_PCM_HW_PARAM_LAST_INTERVAL -
 229                             SNDRV_PCM_HW_PARAM_FIRST_INTERVAL + 1];
 230        unsigned int rules_num;
 231        unsigned int rules_all;
 232        struct snd_pcm_hw_rule *rules;
 233};
 234
 235static inline struct snd_mask *constrs_mask(struct snd_pcm_hw_constraints *constrs,
 236                                            snd_pcm_hw_param_t var)
 237{
 238        return &constrs->masks[var - SNDRV_PCM_HW_PARAM_FIRST_MASK];
 239}
 240
 241static inline struct snd_interval *constrs_interval(struct snd_pcm_hw_constraints *constrs,
 242                                                    snd_pcm_hw_param_t var)
 243{
 244        return &constrs->intervals[var - SNDRV_PCM_HW_PARAM_FIRST_INTERVAL];
 245}
 246
 247struct snd_ratnum {
 248        unsigned int num;
 249        unsigned int den_min, den_max, den_step;
 250};
 251
 252struct snd_ratden {
 253        unsigned int num_min, num_max, num_step;
 254        unsigned int den;
 255};
 256
 257struct snd_pcm_hw_constraint_ratnums {
 258        int nrats;
 259        struct snd_ratnum *rats;
 260};
 261
 262struct snd_pcm_hw_constraint_ratdens {
 263        int nrats;
 264        struct snd_ratden *rats;
 265};
 266
 267struct snd_pcm_hw_constraint_list {
 268        unsigned int count;
 269        const unsigned int *list;
 270        unsigned int mask;
 271};
 272
 273struct snd_pcm_hwptr_log;
 274
 275struct snd_pcm_runtime {
 276        /* -- Status -- */
 277        struct snd_pcm_substream *trigger_master;
 278        struct timespec trigger_tstamp; /* trigger timestamp */
 279        int overrange;
 280        snd_pcm_uframes_t avail_max;
 281        snd_pcm_uframes_t hw_ptr_base;  /* Position at buffer restart */
 282        snd_pcm_uframes_t hw_ptr_interrupt; /* Position at interrupt time */
 283        unsigned long hw_ptr_jiffies;   /* Time when hw_ptr is updated */
 284        unsigned long hw_ptr_buffer_jiffies; /* buffer time in jiffies */
 285        snd_pcm_sframes_t delay;        /* extra delay; typically FIFO size */
 286        u64 hw_ptr_wrap;                /* offset for hw_ptr due to boundary wrap-around */
 287
 288        /* -- HW params -- */
 289        snd_pcm_access_t access;        /* access mode */
 290        snd_pcm_format_t format;        /* SNDRV_PCM_FORMAT_* */
 291        snd_pcm_subformat_t subformat;  /* subformat */
 292        unsigned int rate;              /* rate in Hz */
 293        unsigned int channels;          /* channels */
 294        snd_pcm_uframes_t period_size;  /* period size */
 295        unsigned int periods;           /* periods */
 296        snd_pcm_uframes_t buffer_size;  /* buffer size */
 297        snd_pcm_uframes_t min_align;    /* Min alignment for the format */
 298        size_t byte_align;
 299        unsigned int frame_bits;
 300        unsigned int sample_bits;
 301        unsigned int info;
 302        unsigned int rate_num;
 303        unsigned int rate_den;
 304        unsigned int no_period_wakeup: 1;
 305
 306        /* -- SW params -- */
 307        int tstamp_mode;                /* mmap timestamp is updated */
 308        unsigned int period_step;
 309        snd_pcm_uframes_t start_threshold;
 310        snd_pcm_uframes_t stop_threshold;
 311        snd_pcm_uframes_t silence_threshold; /* Silence filling happens when
 312                                                noise is nearest than this */
 313        snd_pcm_uframes_t silence_size; /* Silence filling size */
 314        snd_pcm_uframes_t boundary;     /* pointers wrap point */
 315
 316        snd_pcm_uframes_t silence_start; /* starting pointer to silence area */
 317        snd_pcm_uframes_t silence_filled; /* size filled with silence */
 318
 319        union snd_pcm_sync_id sync;     /* hardware synchronization ID */
 320
 321        /* -- mmap -- */
 322        struct snd_pcm_mmap_status *status;
 323        struct snd_pcm_mmap_control *control;
 324
 325        /* -- locking / scheduling -- */
 326        snd_pcm_uframes_t twake;        /* do transfer (!poll) wakeup if non-zero */
 327        wait_queue_head_t sleep;        /* poll sleep */
 328        wait_queue_head_t tsleep;       /* transfer sleep */
 329        struct fasync_struct *fasync;
 330
 331        /* -- private section -- */
 332        void *private_data;
 333        void (*private_free)(struct snd_pcm_runtime *runtime);
 334
 335        /* -- hardware description -- */
 336        struct snd_pcm_hardware hw;
 337        struct snd_pcm_hw_constraints hw_constraints;
 338
 339        /* -- interrupt callbacks -- */
 340        void (*transfer_ack_begin)(struct snd_pcm_substream *substream);
 341        void (*transfer_ack_end)(struct snd_pcm_substream *substream);
 342
 343        /* -- timer -- */
 344        unsigned int timer_resolution;  /* timer resolution */
 345        int tstamp_type;                /* timestamp type */
 346
 347        /* -- DMA -- */           
 348        unsigned char *dma_area;        /* DMA area */
 349        dma_addr_t dma_addr;            /* physical bus address (not accessible from main CPU) */
 350        size_t dma_bytes;               /* size of DMA area */
 351
 352        struct snd_dma_buffer *dma_buffer_p;    /* allocated buffer */
 353
 354#if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
 355        /* -- OSS things -- */
 356        struct snd_pcm_oss_runtime oss;
 357#endif
 358
 359#ifdef CONFIG_SND_PCM_XRUN_DEBUG
 360        struct snd_pcm_hwptr_log *hwptr_log;
 361#endif
 362};
 363
 364struct snd_pcm_group {          /* keep linked substreams */
 365        spinlock_t lock;
 366        struct list_head substreams;
 367        int count;
 368};
 369
 370struct pid;
 371
 372struct snd_pcm_substream {
 373        struct snd_pcm *pcm;
 374        struct snd_pcm_str *pstr;
 375        void *private_data;             /* copied from pcm->private_data */
 376        int number;
 377        char name[32];                  /* substream name */
 378        int stream;                     /* stream (direction) */
 379        struct pm_qos_request latency_pm_qos_req; /* pm_qos request */
 380        size_t buffer_bytes_max;        /* limit ring buffer size */
 381        struct snd_dma_buffer dma_buffer;
 382        unsigned int dma_buf_id;
 383        size_t dma_max;
 384        /* -- hardware operations -- */
 385        struct snd_pcm_ops *ops;
 386        /* -- runtime information -- */
 387        struct snd_pcm_runtime *runtime;
 388        /* -- timer section -- */
 389        struct snd_timer *timer;                /* timer */
 390        unsigned timer_running: 1;      /* time is running */
 391        /* -- next substream -- */
 392        struct snd_pcm_substream *next;
 393        /* -- linked substreams -- */
 394        struct list_head link_list;     /* linked list member */
 395        struct snd_pcm_group self_group;        /* fake group for non linked substream (with substream lock inside) */
 396        struct snd_pcm_group *group;            /* pointer to current group */
 397        /* -- assigned files -- */
 398        void *file;
 399        int ref_count;
 400        atomic_t mmap_count;
 401        unsigned int f_flags;
 402        void (*pcm_release)(struct snd_pcm_substream *);
 403        struct pid *pid;
 404#if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
 405        /* -- OSS things -- */
 406        struct snd_pcm_oss_substream oss;
 407#endif
 408#ifdef CONFIG_SND_VERBOSE_PROCFS
 409        struct snd_info_entry *proc_root;
 410        struct snd_info_entry *proc_info_entry;
 411        struct snd_info_entry *proc_hw_params_entry;
 412        struct snd_info_entry *proc_sw_params_entry;
 413        struct snd_info_entry *proc_status_entry;
 414        struct snd_info_entry *proc_prealloc_entry;
 415        struct snd_info_entry *proc_prealloc_max_entry;
 416#endif
 417        /* misc flags */
 418        unsigned int hw_opened: 1;
 419};
 420
 421#define SUBSTREAM_BUSY(substream) ((substream)->ref_count > 0)
 422
 423
 424struct snd_pcm_str {
 425        int stream;                             /* stream (direction) */
 426        struct snd_pcm *pcm;
 427        /* -- substreams -- */
 428        unsigned int substream_count;
 429        unsigned int substream_opened;
 430        struct snd_pcm_substream *substream;
 431#if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
 432        /* -- OSS things -- */
 433        struct snd_pcm_oss_stream oss;
 434#endif
 435#ifdef CONFIG_SND_VERBOSE_PROCFS
 436        struct snd_info_entry *proc_root;
 437        struct snd_info_entry *proc_info_entry;
 438#ifdef CONFIG_SND_PCM_XRUN_DEBUG
 439        unsigned int xrun_debug;        /* 0 = disabled, 1 = verbose, 2 = stacktrace */
 440        struct snd_info_entry *proc_xrun_debug_entry;
 441#endif
 442#endif
 443        struct snd_kcontrol *chmap_kctl; /* channel-mapping controls */
 444};
 445
 446struct snd_pcm {
 447        struct snd_card *card;
 448        struct list_head list;
 449        int device; /* device number */
 450        unsigned int info_flags;
 451        unsigned short dev_class;
 452        unsigned short dev_subclass;
 453        char id[64];
 454        char name[80];
 455        struct snd_pcm_str streams[2];
 456        struct mutex open_mutex;
 457        wait_queue_head_t open_wait;
 458        void *private_data;
 459        void (*private_free) (struct snd_pcm *pcm);
 460        struct device *dev; /* actual hw device this belongs to */
 461        bool internal; /* pcm is for internal use only */
 462#if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
 463        struct snd_pcm_oss oss;
 464#endif
 465};
 466
 467struct snd_pcm_notify {
 468        int (*n_register) (struct snd_pcm * pcm);
 469        int (*n_disconnect) (struct snd_pcm * pcm);
 470        int (*n_unregister) (struct snd_pcm * pcm);
 471        struct list_head list;
 472};
 473
 474/*
 475 *  Registering
 476 */
 477
 478extern const struct file_operations snd_pcm_f_ops[2];
 479
 480int snd_pcm_new(struct snd_card *card, const char *id, int device,
 481                int playback_count, int capture_count,
 482                struct snd_pcm **rpcm);
 483int snd_pcm_new_internal(struct snd_card *card, const char *id, int device,
 484                int playback_count, int capture_count,
 485                struct snd_pcm **rpcm);
 486int snd_pcm_new_stream(struct snd_pcm *pcm, int stream, int substream_count);
 487
 488int snd_pcm_notify(struct snd_pcm_notify *notify, int nfree);
 489
 490/*
 491 *  Native I/O
 492 */
 493
 494extern rwlock_t snd_pcm_link_rwlock;
 495
 496int snd_pcm_info(struct snd_pcm_substream *substream, struct snd_pcm_info *info);
 497int snd_pcm_info_user(struct snd_pcm_substream *substream,
 498                      struct snd_pcm_info __user *info);
 499int snd_pcm_status(struct snd_pcm_substream *substream,
 500                   struct snd_pcm_status *status);
 501int snd_pcm_start(struct snd_pcm_substream *substream);
 502int snd_pcm_stop(struct snd_pcm_substream *substream, snd_pcm_state_t status);
 503int snd_pcm_drain_done(struct snd_pcm_substream *substream);
 504#ifdef CONFIG_PM
 505int snd_pcm_suspend(struct snd_pcm_substream *substream);
 506int snd_pcm_suspend_all(struct snd_pcm *pcm);
 507#endif
 508int snd_pcm_kernel_ioctl(struct snd_pcm_substream *substream, unsigned int cmd, void *arg);
 509int snd_pcm_open_substream(struct snd_pcm *pcm, int stream, struct file *file,
 510                           struct snd_pcm_substream **rsubstream);
 511void snd_pcm_release_substream(struct snd_pcm_substream *substream);
 512int snd_pcm_attach_substream(struct snd_pcm *pcm, int stream, struct file *file,
 513                             struct snd_pcm_substream **rsubstream);
 514void snd_pcm_detach_substream(struct snd_pcm_substream *substream);
 515void snd_pcm_vma_notify_data(void *client, void *data);
 516int snd_pcm_mmap_data(struct snd_pcm_substream *substream, struct file *file, struct vm_area_struct *area);
 517
 518
 519#ifdef CONFIG_SND_DEBUG
 520void snd_pcm_debug_name(struct snd_pcm_substream *substream,
 521                           char *name, size_t len);
 522#else
 523static inline void
 524snd_pcm_debug_name(struct snd_pcm_substream *substream, char *buf, size_t size)
 525{
 526        *buf = 0;
 527}
 528#endif
 529
 530/*
 531 *  PCM library
 532 */
 533
 534static inline int snd_pcm_stream_linked(struct snd_pcm_substream *substream)
 535{
 536        return substream->group != &substream->self_group;
 537}
 538
 539static inline void snd_pcm_stream_lock(struct snd_pcm_substream *substream)
 540{
 541        read_lock(&snd_pcm_link_rwlock);
 542        spin_lock(&substream->self_group.lock);
 543}
 544
 545static inline void snd_pcm_stream_unlock(struct snd_pcm_substream *substream)
 546{
 547        spin_unlock(&substream->self_group.lock);
 548        read_unlock(&snd_pcm_link_rwlock);
 549}
 550
 551static inline void snd_pcm_stream_lock_irq(struct snd_pcm_substream *substream)
 552{
 553        read_lock_irq(&snd_pcm_link_rwlock);
 554        spin_lock(&substream->self_group.lock);
 555}
 556
 557static inline void snd_pcm_stream_unlock_irq(struct snd_pcm_substream *substream)
 558{
 559        spin_unlock(&substream->self_group.lock);
 560        read_unlock_irq(&snd_pcm_link_rwlock);
 561}
 562
 563#define snd_pcm_stream_lock_irqsave(substream, flags) \
 564do { \
 565        read_lock_irqsave(&snd_pcm_link_rwlock, (flags)); \
 566        spin_lock(&substream->self_group.lock); \
 567} while (0)
 568
 569#define snd_pcm_stream_unlock_irqrestore(substream, flags) \
 570do { \
 571        spin_unlock(&substream->self_group.lock); \
 572        read_unlock_irqrestore(&snd_pcm_link_rwlock, (flags)); \
 573} while (0)
 574
 575#define snd_pcm_group_for_each_entry(s, substream) \
 576        list_for_each_entry(s, &substream->group->substreams, link_list)
 577
 578static inline int snd_pcm_running(struct snd_pcm_substream *substream)
 579{
 580        return (substream->runtime->status->state == SNDRV_PCM_STATE_RUNNING ||
 581                (substream->runtime->status->state == SNDRV_PCM_STATE_DRAINING &&
 582                 substream->stream == SNDRV_PCM_STREAM_PLAYBACK));
 583}
 584
 585static inline ssize_t bytes_to_samples(struct snd_pcm_runtime *runtime, ssize_t size)
 586{
 587        return size * 8 / runtime->sample_bits;
 588}
 589
 590static inline snd_pcm_sframes_t bytes_to_frames(struct snd_pcm_runtime *runtime, ssize_t size)
 591{
 592        return size * 8 / runtime->frame_bits;
 593}
 594
 595static inline ssize_t samples_to_bytes(struct snd_pcm_runtime *runtime, ssize_t size)
 596{
 597        return size * runtime->sample_bits / 8;
 598}
 599
 600static inline ssize_t frames_to_bytes(struct snd_pcm_runtime *runtime, snd_pcm_sframes_t size)
 601{
 602        return size * runtime->frame_bits / 8;
 603}
 604
 605static inline int frame_aligned(struct snd_pcm_runtime *runtime, ssize_t bytes)
 606{
 607        return bytes % runtime->byte_align == 0;
 608}
 609
 610static inline size_t snd_pcm_lib_buffer_bytes(struct snd_pcm_substream *substream)
 611{
 612        struct snd_pcm_runtime *runtime = substream->runtime;
 613        return frames_to_bytes(runtime, runtime->buffer_size);
 614}
 615
 616static inline size_t snd_pcm_lib_period_bytes(struct snd_pcm_substream *substream)
 617{
 618        struct snd_pcm_runtime *runtime = substream->runtime;
 619        return frames_to_bytes(runtime, runtime->period_size);
 620}
 621
 622/*
 623 *  result is: 0 ... (boundary - 1)
 624 */
 625static inline snd_pcm_uframes_t snd_pcm_playback_avail(struct snd_pcm_runtime *runtime)
 626{
 627        snd_pcm_sframes_t avail = runtime->status->hw_ptr + runtime->buffer_size - runtime->control->appl_ptr;
 628        if (avail < 0)
 629                avail += runtime->boundary;
 630        else if ((snd_pcm_uframes_t) avail >= runtime->boundary)
 631                avail -= runtime->boundary;
 632        return avail;
 633}
 634
 635/*
 636 *  result is: 0 ... (boundary - 1)
 637 */
 638static inline snd_pcm_uframes_t snd_pcm_capture_avail(struct snd_pcm_runtime *runtime)
 639{
 640        snd_pcm_sframes_t avail = runtime->status->hw_ptr - runtime->control->appl_ptr;
 641        if (avail < 0)
 642                avail += runtime->boundary;
 643        return avail;
 644}
 645
 646static inline snd_pcm_sframes_t snd_pcm_playback_hw_avail(struct snd_pcm_runtime *runtime)
 647{
 648        return runtime->buffer_size - snd_pcm_playback_avail(runtime);
 649}
 650
 651static inline snd_pcm_sframes_t snd_pcm_capture_hw_avail(struct snd_pcm_runtime *runtime)
 652{
 653        return runtime->buffer_size - snd_pcm_capture_avail(runtime);
 654}
 655
 656/**
 657 * snd_pcm_playback_ready - check whether the playback buffer is available
 658 * @substream: the pcm substream instance
 659 *
 660 * Checks whether enough free space is available on the playback buffer.
 661 *
 662 * Returns non-zero if available, or zero if not.
 663 */
 664static inline int snd_pcm_playback_ready(struct snd_pcm_substream *substream)
 665{
 666        struct snd_pcm_runtime *runtime = substream->runtime;
 667        return snd_pcm_playback_avail(runtime) >= runtime->control->avail_min;
 668}
 669
 670/**
 671 * snd_pcm_capture_ready - check whether the capture buffer is available
 672 * @substream: the pcm substream instance
 673 *
 674 * Checks whether enough capture data is available on the capture buffer.
 675 *
 676 * Returns non-zero if available, or zero if not.
 677 */
 678static inline int snd_pcm_capture_ready(struct snd_pcm_substream *substream)
 679{
 680        struct snd_pcm_runtime *runtime = substream->runtime;
 681        return snd_pcm_capture_avail(runtime) >= runtime->control->avail_min;
 682}
 683
 684/**
 685 * snd_pcm_playback_data - check whether any data exists on the playback buffer
 686 * @substream: the pcm substream instance
 687 *
 688 * Checks whether any data exists on the playback buffer. If stop_threshold
 689 * is bigger or equal to boundary, then this function returns always non-zero.
 690 *
 691 * Returns non-zero if exists, or zero if not.
 692 */
 693static inline int snd_pcm_playback_data(struct snd_pcm_substream *substream)
 694{
 695        struct snd_pcm_runtime *runtime = substream->runtime;
 696        
 697        if (runtime->stop_threshold >= runtime->boundary)
 698                return 1;
 699        return snd_pcm_playback_avail(runtime) < runtime->buffer_size;
 700}
 701
 702/**
 703 * snd_pcm_playback_empty - check whether the playback buffer is empty
 704 * @substream: the pcm substream instance
 705 *
 706 * Checks whether the playback buffer is empty.
 707 *
 708 * Returns non-zero if empty, or zero if not.
 709 */
 710static inline int snd_pcm_playback_empty(struct snd_pcm_substream *substream)
 711{
 712        struct snd_pcm_runtime *runtime = substream->runtime;
 713        return snd_pcm_playback_avail(runtime) >= runtime->buffer_size;
 714}
 715
 716/**
 717 * snd_pcm_capture_empty - check whether the capture buffer is empty
 718 * @substream: the pcm substream instance
 719 *
 720 * Checks whether the capture buffer is empty.
 721 *
 722 * Returns non-zero if empty, or zero if not.
 723 */
 724static inline int snd_pcm_capture_empty(struct snd_pcm_substream *substream)
 725{
 726        struct snd_pcm_runtime *runtime = substream->runtime;
 727        return snd_pcm_capture_avail(runtime) == 0;
 728}
 729
 730static inline void snd_pcm_trigger_done(struct snd_pcm_substream *substream, 
 731                                        struct snd_pcm_substream *master)
 732{
 733        substream->runtime->trigger_master = master;
 734}
 735
 736static inline int hw_is_mask(int var)
 737{
 738        return var >= SNDRV_PCM_HW_PARAM_FIRST_MASK &&
 739                var <= SNDRV_PCM_HW_PARAM_LAST_MASK;
 740}
 741
 742static inline int hw_is_interval(int var)
 743{
 744        return var >= SNDRV_PCM_HW_PARAM_FIRST_INTERVAL &&
 745                var <= SNDRV_PCM_HW_PARAM_LAST_INTERVAL;
 746}
 747
 748static inline struct snd_mask *hw_param_mask(struct snd_pcm_hw_params *params,
 749                                     snd_pcm_hw_param_t var)
 750{
 751        return &params->masks[var - SNDRV_PCM_HW_PARAM_FIRST_MASK];
 752}
 753
 754static inline struct snd_interval *hw_param_interval(struct snd_pcm_hw_params *params,
 755                                             snd_pcm_hw_param_t var)
 756{
 757        return &params->intervals[var - SNDRV_PCM_HW_PARAM_FIRST_INTERVAL];
 758}
 759
 760static inline const struct snd_mask *hw_param_mask_c(const struct snd_pcm_hw_params *params,
 761                                             snd_pcm_hw_param_t var)
 762{
 763        return &params->masks[var - SNDRV_PCM_HW_PARAM_FIRST_MASK];
 764}
 765
 766static inline const struct snd_interval *hw_param_interval_c(const struct snd_pcm_hw_params *params,
 767                                                     snd_pcm_hw_param_t var)
 768{
 769        return &params->intervals[var - SNDRV_PCM_HW_PARAM_FIRST_INTERVAL];
 770}
 771
 772#define params_channels(p) \
 773        (hw_param_interval_c((p), SNDRV_PCM_HW_PARAM_CHANNELS)->min)
 774#define params_rate(p) \
 775        (hw_param_interval_c((p), SNDRV_PCM_HW_PARAM_RATE)->min)
 776#define params_period_size(p) \
 777        (hw_param_interval_c((p), SNDRV_PCM_HW_PARAM_PERIOD_SIZE)->min)
 778#define params_periods(p) \
 779        (hw_param_interval_c((p), SNDRV_PCM_HW_PARAM_PERIODS)->min)
 780#define params_buffer_size(p) \
 781        (hw_param_interval_c((p), SNDRV_PCM_HW_PARAM_BUFFER_SIZE)->min)
 782#define params_buffer_bytes(p) \
 783        (hw_param_interval_c((p), SNDRV_PCM_HW_PARAM_BUFFER_BYTES)->min)
 784
 785int snd_interval_refine(struct snd_interval *i, const struct snd_interval *v);
 786void snd_interval_mul(const struct snd_interval *a, const struct snd_interval *b, struct snd_interval *c);
 787void snd_interval_div(const struct snd_interval *a, const struct snd_interval *b, struct snd_interval *c);
 788void snd_interval_muldivk(const struct snd_interval *a, const struct snd_interval *b, 
 789                          unsigned int k, struct snd_interval *c);
 790void snd_interval_mulkdiv(const struct snd_interval *a, unsigned int k,
 791                          const struct snd_interval *b, struct snd_interval *c);
 792int snd_interval_list(struct snd_interval *i, unsigned int count,
 793                      const unsigned int *list, unsigned int mask);
 794int snd_interval_ratnum(struct snd_interval *i,
 795                        unsigned int rats_count, struct snd_ratnum *rats,
 796                        unsigned int *nump, unsigned int *denp);
 797
 798void _snd_pcm_hw_params_any(struct snd_pcm_hw_params *params);
 799void _snd_pcm_hw_param_setempty(struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var);
 800int snd_pcm_hw_params_choose(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params);
 801
 802int snd_pcm_hw_refine(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params);
 803
 804int snd_pcm_hw_constraints_init(struct snd_pcm_substream *substream);
 805int snd_pcm_hw_constraints_complete(struct snd_pcm_substream *substream);
 806
 807int snd_pcm_hw_constraint_mask(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var,
 808                               u_int32_t mask);
 809int snd_pcm_hw_constraint_mask64(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var,
 810                                 u_int64_t mask);
 811int snd_pcm_hw_constraint_minmax(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var,
 812                                 unsigned int min, unsigned int max);
 813int snd_pcm_hw_constraint_integer(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var);
 814int snd_pcm_hw_constraint_list(struct snd_pcm_runtime *runtime, 
 815                               unsigned int cond,
 816                               snd_pcm_hw_param_t var,
 817                               const struct snd_pcm_hw_constraint_list *l);
 818int snd_pcm_hw_constraint_ratnums(struct snd_pcm_runtime *runtime, 
 819                                  unsigned int cond,
 820                                  snd_pcm_hw_param_t var,
 821                                  struct snd_pcm_hw_constraint_ratnums *r);
 822int snd_pcm_hw_constraint_ratdens(struct snd_pcm_runtime *runtime, 
 823                                  unsigned int cond,
 824                                  snd_pcm_hw_param_t var,
 825                                  struct snd_pcm_hw_constraint_ratdens *r);
 826int snd_pcm_hw_constraint_msbits(struct snd_pcm_runtime *runtime, 
 827                                 unsigned int cond,
 828                                 unsigned int width,
 829                                 unsigned int msbits);
 830int snd_pcm_hw_constraint_step(struct snd_pcm_runtime *runtime,
 831                               unsigned int cond,
 832                               snd_pcm_hw_param_t var,
 833                               unsigned long step);
 834int snd_pcm_hw_constraint_pow2(struct snd_pcm_runtime *runtime,
 835                               unsigned int cond,
 836                               snd_pcm_hw_param_t var);
 837int snd_pcm_hw_rule_noresample(struct snd_pcm_runtime *runtime,
 838                               unsigned int base_rate);
 839int snd_pcm_hw_rule_add(struct snd_pcm_runtime *runtime,
 840                        unsigned int cond,
 841                        int var,
 842                        snd_pcm_hw_rule_func_t func, void *private,
 843                        int dep, ...);
 844
 845int snd_pcm_format_signed(snd_pcm_format_t format);
 846int snd_pcm_format_unsigned(snd_pcm_format_t format);
 847int snd_pcm_format_linear(snd_pcm_format_t format);
 848int snd_pcm_format_little_endian(snd_pcm_format_t format);
 849int snd_pcm_format_big_endian(snd_pcm_format_t format);
 850#if 0 /* just for DocBook */
 851/**
 852 * snd_pcm_format_cpu_endian - Check the PCM format is CPU-endian
 853 * @format: the format to check
 854 *
 855 * Returns 1 if the given PCM format is CPU-endian, 0 if
 856 * opposite, or a negative error code if endian not specified.
 857 */
 858int snd_pcm_format_cpu_endian(snd_pcm_format_t format);
 859#endif /* DocBook */
 860#ifdef SNDRV_LITTLE_ENDIAN
 861#define snd_pcm_format_cpu_endian(format) snd_pcm_format_little_endian(format)
 862#else
 863#define snd_pcm_format_cpu_endian(format) snd_pcm_format_big_endian(format)
 864#endif
 865int snd_pcm_format_width(snd_pcm_format_t format);                      /* in bits */
 866int snd_pcm_format_physical_width(snd_pcm_format_t format);             /* in bits */
 867ssize_t snd_pcm_format_size(snd_pcm_format_t format, size_t samples);
 868const unsigned char *snd_pcm_format_silence_64(snd_pcm_format_t format);
 869int snd_pcm_format_set_silence(snd_pcm_format_t format, void *buf, unsigned int frames);
 870snd_pcm_format_t snd_pcm_build_linear_format(int width, int unsignd, int big_endian);
 871
 872void snd_pcm_set_ops(struct snd_pcm * pcm, int direction, struct snd_pcm_ops *ops);
 873void snd_pcm_set_sync(struct snd_pcm_substream *substream);
 874int snd_pcm_lib_interleave_len(struct snd_pcm_substream *substream);
 875int snd_pcm_lib_ioctl(struct snd_pcm_substream *substream,
 876                      unsigned int cmd, void *arg);                      
 877int snd_pcm_update_state(struct snd_pcm_substream *substream,
 878                         struct snd_pcm_runtime *runtime);
 879int snd_pcm_update_hw_ptr(struct snd_pcm_substream *substream);
 880int snd_pcm_playback_xrun_check(struct snd_pcm_substream *substream);
 881int snd_pcm_capture_xrun_check(struct snd_pcm_substream *substream);
 882int snd_pcm_playback_xrun_asap(struct snd_pcm_substream *substream);
 883int snd_pcm_capture_xrun_asap(struct snd_pcm_substream *substream);
 884void snd_pcm_playback_silence(struct snd_pcm_substream *substream, snd_pcm_uframes_t new_hw_ptr);
 885void snd_pcm_period_elapsed(struct snd_pcm_substream *substream);
 886snd_pcm_sframes_t snd_pcm_lib_write(struct snd_pcm_substream *substream,
 887                                    const void __user *buf,
 888                                    snd_pcm_uframes_t frames);
 889snd_pcm_sframes_t snd_pcm_lib_read(struct snd_pcm_substream *substream,
 890                                   void __user *buf, snd_pcm_uframes_t frames);
 891snd_pcm_sframes_t snd_pcm_lib_writev(struct snd_pcm_substream *substream,
 892                                     void __user **bufs, snd_pcm_uframes_t frames);
 893snd_pcm_sframes_t snd_pcm_lib_readv(struct snd_pcm_substream *substream,
 894                                    void __user **bufs, snd_pcm_uframes_t frames);
 895
 896extern const struct snd_pcm_hw_constraint_list snd_pcm_known_rates;
 897
 898int snd_pcm_limit_hw_rates(struct snd_pcm_runtime *runtime);
 899unsigned int snd_pcm_rate_to_rate_bit(unsigned int rate);
 900unsigned int snd_pcm_rate_bit_to_rate(unsigned int rate_bit);
 901
 902static inline void snd_pcm_set_runtime_buffer(struct snd_pcm_substream *substream,
 903                                              struct snd_dma_buffer *bufp)
 904{
 905        struct snd_pcm_runtime *runtime = substream->runtime;
 906        if (bufp) {
 907                runtime->dma_buffer_p = bufp;
 908                runtime->dma_area = bufp->area;
 909                runtime->dma_addr = bufp->addr;
 910                runtime->dma_bytes = bufp->bytes;
 911        } else {
 912                runtime->dma_buffer_p = NULL;
 913                runtime->dma_area = NULL;
 914                runtime->dma_addr = 0;
 915                runtime->dma_bytes = 0;
 916        }
 917}
 918
 919/*
 920 *  Timer interface
 921 */
 922
 923void snd_pcm_timer_resolution_change(struct snd_pcm_substream *substream);
 924void snd_pcm_timer_init(struct snd_pcm_substream *substream);
 925void snd_pcm_timer_done(struct snd_pcm_substream *substream);
 926
 927static inline void snd_pcm_gettime(struct snd_pcm_runtime *runtime,
 928                                   struct timespec *tv)
 929{
 930        if (runtime->tstamp_type == SNDRV_PCM_TSTAMP_TYPE_MONOTONIC)
 931                do_posix_clock_monotonic_gettime(tv);
 932        else
 933                getnstimeofday(tv);
 934}
 935
 936/*
 937 *  Memory
 938 */
 939
 940int snd_pcm_lib_preallocate_free(struct snd_pcm_substream *substream);
 941int snd_pcm_lib_preallocate_free_for_all(struct snd_pcm *pcm);
 942int snd_pcm_lib_preallocate_pages(struct snd_pcm_substream *substream,
 943                                  int type, struct device *data,
 944                                  size_t size, size_t max);
 945int snd_pcm_lib_preallocate_pages_for_all(struct snd_pcm *pcm,
 946                                          int type, void *data,
 947                                          size_t size, size_t max);
 948int snd_pcm_lib_malloc_pages(struct snd_pcm_substream *substream, size_t size);
 949int snd_pcm_lib_free_pages(struct snd_pcm_substream *substream);
 950
 951int _snd_pcm_lib_alloc_vmalloc_buffer(struct snd_pcm_substream *substream,
 952                                      size_t size, gfp_t gfp_flags);
 953int snd_pcm_lib_free_vmalloc_buffer(struct snd_pcm_substream *substream);
 954struct page *snd_pcm_lib_get_vmalloc_page(struct snd_pcm_substream *substream,
 955                                          unsigned long offset);
 956#if 0 /* for kernel-doc */
 957/**
 958 * snd_pcm_lib_alloc_vmalloc_buffer - allocate virtual DMA buffer
 959 * @substream: the substream to allocate the buffer to
 960 * @size: the requested buffer size, in bytes
 961 *
 962 * Allocates the PCM substream buffer using vmalloc(), i.e., the memory is
 963 * contiguous in kernel virtual space, but not in physical memory.  Use this
 964 * if the buffer is accessed by kernel code but not by device DMA.
 965 *
 966 * Returns 1 if the buffer was changed, 0 if not changed, or a negative error
 967 * code.
 968 */
 969static int snd_pcm_lib_alloc_vmalloc_buffer
 970                        (struct snd_pcm_substream *substream, size_t size);
 971/**
 972 * snd_pcm_lib_alloc_vmalloc_32_buffer - allocate 32-bit-addressable buffer
 973 * @substream: the substream to allocate the buffer to
 974 * @size: the requested buffer size, in bytes
 975 *
 976 * This function works like snd_pcm_lib_alloc_vmalloc_buffer(), but uses
 977 * vmalloc_32(), i.e., the pages are allocated from 32-bit-addressable memory.
 978 */
 979static int snd_pcm_lib_alloc_vmalloc_32_buffer
 980                        (struct snd_pcm_substream *substream, size_t size);
 981#endif
 982#define snd_pcm_lib_alloc_vmalloc_buffer(subs, size) \
 983        _snd_pcm_lib_alloc_vmalloc_buffer \
 984                        (subs, size, GFP_KERNEL | __GFP_HIGHMEM | __GFP_ZERO)
 985#define snd_pcm_lib_alloc_vmalloc_32_buffer(subs, size) \
 986        _snd_pcm_lib_alloc_vmalloc_buffer \
 987                        (subs, size, GFP_KERNEL | GFP_DMA32 | __GFP_ZERO)
 988
 989#define snd_pcm_get_dma_buf(substream) ((substream)->runtime->dma_buffer_p)
 990
 991#ifdef CONFIG_SND_DMA_SGBUF
 992/*
 993 * SG-buffer handling
 994 */
 995#define snd_pcm_substream_sgbuf(substream) \
 996        snd_pcm_get_dma_buf(substream)->private_data
 997
 998struct page *snd_pcm_sgbuf_ops_page(struct snd_pcm_substream *substream,
 999                                    unsigned long offset);
1000#else /* !SND_DMA_SGBUF */
1001/*
1002 * fake using a continuous buffer
1003 */
1004#define snd_pcm_sgbuf_ops_page  NULL
1005#endif /* SND_DMA_SGBUF */
1006
1007static inline dma_addr_t
1008snd_pcm_sgbuf_get_addr(struct snd_pcm_substream *substream, unsigned int ofs)
1009{
1010        return snd_sgbuf_get_addr(snd_pcm_get_dma_buf(substream), ofs);
1011}
1012
1013static inline void *
1014snd_pcm_sgbuf_get_ptr(struct snd_pcm_substream *substream, unsigned int ofs)
1015{
1016        return snd_sgbuf_get_ptr(snd_pcm_get_dma_buf(substream), ofs);
1017}
1018
1019static inline unsigned int
1020snd_pcm_sgbuf_get_chunk_size(struct snd_pcm_substream *substream,
1021                             unsigned int ofs, unsigned int size)
1022{
1023        return snd_sgbuf_get_chunk_size(snd_pcm_get_dma_buf(substream), ofs, size);
1024}
1025
1026/* handle mmap counter - PCM mmap callback should handle this counter properly */
1027static inline void snd_pcm_mmap_data_open(struct vm_area_struct *area)
1028{
1029        struct snd_pcm_substream *substream = (struct snd_pcm_substream *)area->vm_private_data;
1030        atomic_inc(&substream->mmap_count);
1031}
1032
1033static inline void snd_pcm_mmap_data_close(struct vm_area_struct *area)
1034{
1035        struct snd_pcm_substream *substream = (struct snd_pcm_substream *)area->vm_private_data;
1036        atomic_dec(&substream->mmap_count);
1037}
1038
1039int snd_pcm_lib_default_mmap(struct snd_pcm_substream *substream,
1040                             struct vm_area_struct *area);
1041/* mmap for io-memory area */
1042#if defined(CONFIG_X86) || defined(CONFIG_PPC) || defined(CONFIG_ALPHA)
1043#define SNDRV_PCM_INFO_MMAP_IOMEM       SNDRV_PCM_INFO_MMAP
1044int snd_pcm_lib_mmap_iomem(struct snd_pcm_substream *substream, struct vm_area_struct *area);
1045#else
1046#define SNDRV_PCM_INFO_MMAP_IOMEM       0
1047#define snd_pcm_lib_mmap_iomem  NULL
1048#endif
1049
1050#define snd_pcm_lib_mmap_vmalloc NULL
1051
1052static inline void snd_pcm_limit_isa_dma_size(int dma, size_t *max)
1053{
1054        *max = dma < 4 ? 64 * 1024 : 128 * 1024;
1055}
1056
1057/*
1058 *  Misc
1059 */
1060
1061#define SNDRV_PCM_DEFAULT_CON_SPDIF     (IEC958_AES0_CON_EMPHASIS_NONE|\
1062                                         (IEC958_AES1_CON_ORIGINAL<<8)|\
1063                                         (IEC958_AES1_CON_PCM_CODER<<8)|\
1064                                         (IEC958_AES3_CON_FS_48000<<24))
1065
1066#define PCM_RUNTIME_CHECK(sub) snd_BUG_ON(!(sub) || !(sub)->runtime)
1067
1068const char *snd_pcm_format_name(snd_pcm_format_t format);
1069
1070/**
1071 * snd_pcm_stream_str - Get a string naming the direction of a stream
1072 * @substream: the pcm substream instance
1073 */
1074static inline const char *snd_pcm_stream_str(struct snd_pcm_substream *substream)
1075{
1076        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
1077                return "Playback";
1078        else
1079                return "Capture";
1080}
1081
1082/*
1083 * PCM channel-mapping control API
1084 */
1085/* array element of channel maps */
1086struct snd_pcm_chmap_elem {
1087        unsigned char channels;
1088        unsigned char map[15];
1089};
1090
1091/* channel map information; retrieved via snd_kcontrol_chip() */
1092struct snd_pcm_chmap {
1093        struct snd_pcm *pcm;    /* assigned PCM instance */
1094        int stream;             /* PLAYBACK or CAPTURE */
1095        struct snd_kcontrol *kctl;
1096        const struct snd_pcm_chmap_elem *chmap;
1097        unsigned int max_channels;
1098        unsigned int channel_mask;      /* optional: active channels bitmask */
1099        void *private_data;     /* optional: private data pointer */
1100};
1101
1102/* get the PCM substream assigned to the given chmap info */
1103static inline struct snd_pcm_substream *
1104snd_pcm_chmap_substream(struct snd_pcm_chmap *info, unsigned int idx)
1105{
1106        struct snd_pcm_substream *s;
1107        for (s = info->pcm->streams[info->stream].substream; s; s = s->next)
1108                if (s->number == idx)
1109                        return s;
1110        return NULL;
1111}
1112
1113/* ALSA-standard channel maps (RL/RR prior to C/LFE) */
1114extern const struct snd_pcm_chmap_elem snd_pcm_std_chmaps[];
1115/* Other world's standard channel maps (C/LFE prior to RL/RR) */
1116extern const struct snd_pcm_chmap_elem snd_pcm_alt_chmaps[];
1117
1118/* bit masks to be passed to snd_pcm_chmap.channel_mask field */
1119#define SND_PCM_CHMAP_MASK_24   ((1U << 2) | (1U << 4))
1120#define SND_PCM_CHMAP_MASK_246  (SND_PCM_CHMAP_MASK_24 | (1U << 6))
1121#define SND_PCM_CHMAP_MASK_2468 (SND_PCM_CHMAP_MASK_246 | (1U << 8))
1122
1123int snd_pcm_add_chmap_ctls(struct snd_pcm *pcm, int stream,
1124                           const struct snd_pcm_chmap_elem *chmap,
1125                           int max_channels,
1126                           unsigned long private_value,
1127                           struct snd_pcm_chmap **info_ret);
1128
1129#endif /* __SOUND_PCM_H */
1130
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.