home *** CD-ROM | disk | FTP | other *** search
/ PC Welt 2006 November (DVD) / PCWELT_11_2006.ISO / casper / filesystem.squashfs / usr / src / linux-headers-2.6.17-6 / include / sound / pcm.h < prev    next >
Encoding:
C/C++ Source or Header  |  2006-08-11  |  34.9 KB  |  1,008 lines
  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@suse.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 <linux/poll.h>
  29. #include <linux/bitops.h>
  30.  
  31. #define snd_pcm_substream_chip(substream) ((substream)->private_data)
  32. #define snd_pcm_chip(pcm) ((pcm)->private_data)
  33.  
  34. #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
  35. #include "pcm_oss.h"
  36. #endif
  37.  
  38. /*
  39.  *  Hardware (lowlevel) section
  40.  */
  41.  
  42. struct snd_pcm_hardware {
  43.     unsigned int info;        /* SNDRV_PCM_INFO_* */
  44.     u64 formats;            /* SNDRV_PCM_FMTBIT_* */
  45.     unsigned int rates;        /* SNDRV_PCM_RATE_* */
  46.     unsigned int rate_min;        /* min rate */
  47.     unsigned int rate_max;        /* max rate */
  48.     unsigned int channels_min;    /* min channels */
  49.     unsigned int channels_max;    /* max channels */
  50.     size_t buffer_bytes_max;    /* max buffer size */
  51.     size_t period_bytes_min;    /* min period size */
  52.     size_t period_bytes_max;    /* max period size */
  53.     unsigned int periods_min;    /* min # of periods */
  54.     unsigned int periods_max;    /* max # of periods */
  55.     size_t fifo_size;        /* fifo size in bytes */
  56. };
  57.  
  58. struct snd_pcm_ops {
  59.     int (*open)(struct snd_pcm_substream *substream);
  60.     int (*close)(struct snd_pcm_substream *substream);
  61.     int (*ioctl)(struct snd_pcm_substream * substream,
  62.              unsigned int cmd, void *arg);
  63.     int (*hw_params)(struct snd_pcm_substream *substream,
  64.              struct snd_pcm_hw_params *params);
  65.     int (*hw_free)(struct snd_pcm_substream *substream);
  66.     int (*prepare)(struct snd_pcm_substream *substream);
  67.     int (*trigger)(struct snd_pcm_substream *substream, int cmd);
  68.     snd_pcm_uframes_t (*pointer)(struct snd_pcm_substream *substream);
  69.     int (*copy)(struct snd_pcm_substream *substream, int channel,
  70.             snd_pcm_uframes_t pos,
  71.             void __user *buf, snd_pcm_uframes_t count);
  72.     int (*silence)(struct snd_pcm_substream *substream, int channel, 
  73.                snd_pcm_uframes_t pos, snd_pcm_uframes_t count);
  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. #define SNDRV_PCM_DEVICES        8
  85.  
  86. #define SNDRV_PCM_IOCTL1_FALSE        ((void *)0)
  87. #define SNDRV_PCM_IOCTL1_TRUE        ((void *)1)
  88.  
  89. #define SNDRV_PCM_IOCTL1_RESET        0
  90. #define SNDRV_PCM_IOCTL1_INFO        1
  91. #define SNDRV_PCM_IOCTL1_CHANNEL_INFO    2
  92. #define SNDRV_PCM_IOCTL1_GSTATE        3
  93.  
  94. #define SNDRV_PCM_TRIGGER_STOP        0
  95. #define SNDRV_PCM_TRIGGER_START        1
  96. #define SNDRV_PCM_TRIGGER_PAUSE_PUSH    3
  97. #define SNDRV_PCM_TRIGGER_PAUSE_RELEASE    4
  98. #define SNDRV_PCM_TRIGGER_SUSPEND    5
  99. #define SNDRV_PCM_TRIGGER_RESUME    6
  100.  
  101. #define SNDRV_PCM_POS_XRUN        ((snd_pcm_uframes_t)-1)
  102.  
  103. /* If you change this don't forget to change rates[] table in pcm_native.c */
  104. #define SNDRV_PCM_RATE_5512        (1<<0)        /* 5512Hz */
  105. #define SNDRV_PCM_RATE_8000        (1<<1)        /* 8000Hz */
  106. #define SNDRV_PCM_RATE_11025        (1<<2)        /* 11025Hz */
  107. #define SNDRV_PCM_RATE_16000        (1<<3)        /* 16000Hz */
  108. #define SNDRV_PCM_RATE_22050        (1<<4)        /* 22050Hz */
  109. #define SNDRV_PCM_RATE_32000        (1<<5)        /* 32000Hz */
  110. #define SNDRV_PCM_RATE_44100        (1<<6)        /* 44100Hz */
  111. #define SNDRV_PCM_RATE_48000        (1<<7)        /* 48000Hz */
  112. #define SNDRV_PCM_RATE_64000        (1<<8)        /* 64000Hz */
  113. #define SNDRV_PCM_RATE_88200        (1<<9)        /* 88200Hz */
  114. #define SNDRV_PCM_RATE_96000        (1<<10)        /* 96000Hz */
  115. #define SNDRV_PCM_RATE_176400        (1<<11)        /* 176400Hz */
  116. #define SNDRV_PCM_RATE_192000        (1<<12)        /* 192000Hz */
  117.  
  118. #define SNDRV_PCM_RATE_CONTINUOUS    (1<<30)        /* continuous range */
  119. #define SNDRV_PCM_RATE_KNOT        (1<<31)        /* supports more non-continuos rates */
  120.  
  121. #define SNDRV_PCM_RATE_8000_44100    (SNDRV_PCM_RATE_8000|SNDRV_PCM_RATE_11025|\
  122.                      SNDRV_PCM_RATE_16000|SNDRV_PCM_RATE_22050|\
  123.                      SNDRV_PCM_RATE_32000|SNDRV_PCM_RATE_44100)
  124. #define SNDRV_PCM_RATE_8000_48000    (SNDRV_PCM_RATE_8000_44100|SNDRV_PCM_RATE_48000)
  125. #define SNDRV_PCM_RATE_8000_96000    (SNDRV_PCM_RATE_8000_48000|SNDRV_PCM_RATE_64000|\
  126.                      SNDRV_PCM_RATE_88200|SNDRV_PCM_RATE_96000)
  127. #define SNDRV_PCM_RATE_8000_192000    (SNDRV_PCM_RATE_8000_96000|SNDRV_PCM_RATE_176400|\
  128.                      SNDRV_PCM_RATE_192000)
  129. #define SNDRV_PCM_FMTBIT_S8        (1ULL << SNDRV_PCM_FORMAT_S8)
  130. #define SNDRV_PCM_FMTBIT_U8        (1ULL << SNDRV_PCM_FORMAT_U8)
  131. #define SNDRV_PCM_FMTBIT_S16_LE        (1ULL << SNDRV_PCM_FORMAT_S16_LE)
  132. #define SNDRV_PCM_FMTBIT_S16_BE        (1ULL << SNDRV_PCM_FORMAT_S16_BE)
  133. #define SNDRV_PCM_FMTBIT_U16_LE        (1ULL << SNDRV_PCM_FORMAT_U16_LE)
  134. #define SNDRV_PCM_FMTBIT_U16_BE        (1ULL << SNDRV_PCM_FORMAT_U16_BE)
  135. #define SNDRV_PCM_FMTBIT_S24_LE        (1ULL << SNDRV_PCM_FORMAT_S24_LE)
  136. #define SNDRV_PCM_FMTBIT_S24_BE        (1ULL << SNDRV_PCM_FORMAT_S24_BE)
  137. #define SNDRV_PCM_FMTBIT_U24_LE        (1ULL << SNDRV_PCM_FORMAT_U24_LE)
  138. #define SNDRV_PCM_FMTBIT_U24_BE        (1ULL << SNDRV_PCM_FORMAT_U24_BE)
  139. #define SNDRV_PCM_FMTBIT_S32_LE        (1ULL << SNDRV_PCM_FORMAT_S32_LE)
  140. #define SNDRV_PCM_FMTBIT_S32_BE        (1ULL << SNDRV_PCM_FORMAT_S32_BE)
  141. #define SNDRV_PCM_FMTBIT_U32_LE        (1ULL << SNDRV_PCM_FORMAT_U32_LE)
  142. #define SNDRV_PCM_FMTBIT_U32_BE        (1ULL << SNDRV_PCM_FORMAT_U32_BE)
  143. #define SNDRV_PCM_FMTBIT_FLOAT_LE    (1ULL << SNDRV_PCM_FORMAT_FLOAT_LE)
  144. #define SNDRV_PCM_FMTBIT_FLOAT_BE    (1ULL << SNDRV_PCM_FORMAT_FLOAT_BE)
  145. #define SNDRV_PCM_FMTBIT_FLOAT64_LE    (1ULL << SNDRV_PCM_FORMAT_FLOAT64_LE)
  146. #define SNDRV_PCM_FMTBIT_FLOAT64_BE    (1ULL << SNDRV_PCM_FORMAT_FLOAT64_BE)
  147. #define SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE (1ULL << SNDRV_PCM_FORMAT_IEC958_SUBFRAME_LE)
  148. #define SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_BE (1ULL << SNDRV_PCM_FORMAT_IEC958_SUBFRAME_BE)
  149. #define SNDRV_PCM_FMTBIT_MU_LAW        (1ULL << SNDRV_PCM_FORMAT_MU_LAW)
  150. #define SNDRV_PCM_FMTBIT_A_LAW        (1ULL << SNDRV_PCM_FORMAT_A_LAW)
  151. #define SNDRV_PCM_FMTBIT_IMA_ADPCM    (1ULL << SNDRV_PCM_FORMAT_IMA_ADPCM)
  152. #define SNDRV_PCM_FMTBIT_MPEG        (1ULL << SNDRV_PCM_FORMAT_MPEG)
  153. #define SNDRV_PCM_FMTBIT_GSM        (1ULL << SNDRV_PCM_FORMAT_GSM)
  154. #define SNDRV_PCM_FMTBIT_SPECIAL    (1ULL << SNDRV_PCM_FORMAT_SPECIAL)
  155. #define SNDRV_PCM_FMTBIT_S24_3LE    (1ULL << SNDRV_PCM_FORMAT_S24_3LE)
  156. #define SNDRV_PCM_FMTBIT_U24_3LE    (1ULL << SNDRV_PCM_FORMAT_U24_3LE)
  157. #define SNDRV_PCM_FMTBIT_S24_3BE    (1ULL << SNDRV_PCM_FORMAT_S24_3BE)
  158. #define SNDRV_PCM_FMTBIT_U24_3BE    (1ULL << SNDRV_PCM_FORMAT_U24_3BE)
  159. #define SNDRV_PCM_FMTBIT_S20_3LE    (1ULL << SNDRV_PCM_FORMAT_S20_3LE)
  160. #define SNDRV_PCM_FMTBIT_U20_3LE    (1ULL << SNDRV_PCM_FORMAT_U20_3LE)
  161. #define SNDRV_PCM_FMTBIT_S20_3BE    (1ULL << SNDRV_PCM_FORMAT_S20_3BE)
  162. #define SNDRV_PCM_FMTBIT_U20_3BE    (1ULL << SNDRV_PCM_FORMAT_U20_3BE)
  163. #define SNDRV_PCM_FMTBIT_S18_3LE    (1ULL << SNDRV_PCM_FORMAT_S18_3LE)
  164. #define SNDRV_PCM_FMTBIT_U18_3LE    (1ULL << SNDRV_PCM_FORMAT_U18_3LE)
  165. #define SNDRV_PCM_FMTBIT_S18_3BE    (1ULL << SNDRV_PCM_FORMAT_S18_3BE)
  166. #define SNDRV_PCM_FMTBIT_U18_3BE    (1ULL << SNDRV_PCM_FORMAT_U18_3BE)
  167.  
  168. #ifdef SNDRV_LITTLE_ENDIAN
  169. #define SNDRV_PCM_FMTBIT_S16        SNDRV_PCM_FMTBIT_S16_LE
  170. #define SNDRV_PCM_FMTBIT_U16        SNDRV_PCM_FMTBIT_U16_LE
  171. #define SNDRV_PCM_FMTBIT_S24        SNDRV_PCM_FMTBIT_S24_LE
  172. #define SNDRV_PCM_FMTBIT_U24        SNDRV_PCM_FMTBIT_U24_LE
  173. #define SNDRV_PCM_FMTBIT_S32        SNDRV_PCM_FMTBIT_S32_LE
  174. #define SNDRV_PCM_FMTBIT_U32        SNDRV_PCM_FMTBIT_U32_LE
  175. #define SNDRV_PCM_FMTBIT_FLOAT        SNDRV_PCM_FMTBIT_FLOAT_LE
  176. #define SNDRV_PCM_FMTBIT_FLOAT64    SNDRV_PCM_FMTBIT_FLOAT64_LE
  177. #define SNDRV_PCM_FMTBIT_IEC958_SUBFRAME SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE
  178. #endif
  179. #ifdef SNDRV_BIG_ENDIAN
  180. #define SNDRV_PCM_FMTBIT_S16        SNDRV_PCM_FMTBIT_S16_BE
  181. #define SNDRV_PCM_FMTBIT_U16        SNDRV_PCM_FMTBIT_U16_BE
  182. #define SNDRV_PCM_FMTBIT_S24        SNDRV_PCM_FMTBIT_S24_BE
  183. #define SNDRV_PCM_FMTBIT_U24        SNDRV_PCM_FMTBIT_U24_BE
  184. #define SNDRV_PCM_FMTBIT_S32        SNDRV_PCM_FMTBIT_S32_BE
  185. #define SNDRV_PCM_FMTBIT_U32        SNDRV_PCM_FMTBIT_U32_BE
  186. #define SNDRV_PCM_FMTBIT_FLOAT        SNDRV_PCM_FMTBIT_FLOAT_BE
  187. #define SNDRV_PCM_FMTBIT_FLOAT64    SNDRV_PCM_FMTBIT_FLOAT64_BE
  188. #define SNDRV_PCM_FMTBIT_IEC958_SUBFRAME SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_BE
  189. #endif
  190.  
  191. struct snd_pcm_file {
  192.     struct snd_pcm_substream *substream;
  193.     struct snd_pcm_file *next;
  194. };
  195.  
  196. struct snd_pcm_hw_rule;
  197. typedef int (*snd_pcm_hw_rule_func_t)(struct snd_pcm_hw_params *params,
  198.                       struct snd_pcm_hw_rule *rule);
  199.  
  200. struct snd_pcm_hw_rule {
  201.     unsigned int cond;
  202.     snd_pcm_hw_rule_func_t func;
  203.     int var;
  204.     int deps[4];
  205.     void *private;
  206. };
  207.  
  208. struct snd_pcm_hw_constraints {
  209.     struct snd_mask masks[SNDRV_PCM_HW_PARAM_LAST_MASK - 
  210.              SNDRV_PCM_HW_PARAM_FIRST_MASK + 1];
  211.     struct snd_interval intervals[SNDRV_PCM_HW_PARAM_LAST_INTERVAL -
  212.                  SNDRV_PCM_HW_PARAM_FIRST_INTERVAL + 1];
  213.     unsigned int rules_num;
  214.     unsigned int rules_all;
  215.     struct snd_pcm_hw_rule *rules;
  216. };
  217.  
  218. static inline struct snd_mask *constrs_mask(struct snd_pcm_hw_constraints *constrs,
  219.                         snd_pcm_hw_param_t var)
  220. {
  221.     return &constrs->masks[var - SNDRV_PCM_HW_PARAM_FIRST_MASK];
  222. }
  223.  
  224. static inline struct snd_interval *constrs_interval(struct snd_pcm_hw_constraints *constrs,
  225.                             snd_pcm_hw_param_t var)
  226. {
  227.     return &constrs->intervals[var - SNDRV_PCM_HW_PARAM_FIRST_INTERVAL];
  228. }
  229.  
  230. struct snd_ratnum {
  231.     unsigned int num;
  232.     unsigned int den_min, den_max, den_step;
  233. };
  234.  
  235. struct snd_ratden {
  236.     unsigned int num_min, num_max, num_step;
  237.     unsigned int den;
  238. };
  239.  
  240. struct snd_pcm_hw_constraint_ratnums {
  241.     int nrats;
  242.     struct snd_ratnum *rats;
  243. };
  244.  
  245. struct snd_pcm_hw_constraint_ratdens {
  246.     int nrats;
  247.     struct snd_ratden *rats;
  248. };
  249.  
  250. struct snd_pcm_hw_constraint_list {
  251.     unsigned int count;
  252.     unsigned int *list;
  253.     unsigned int mask;
  254. };
  255.  
  256. struct snd_pcm_runtime {
  257.     /* -- Status -- */
  258.     struct snd_pcm_substream *trigger_master;
  259.     struct timespec trigger_tstamp;    /* trigger timestamp */
  260.     int overrange;
  261.     snd_pcm_uframes_t avail_max;
  262.     snd_pcm_uframes_t hw_ptr_base;    /* Position at buffer restart */
  263.     snd_pcm_uframes_t hw_ptr_interrupt; /* Position at interrupt time*/
  264.  
  265.     /* -- HW params -- */
  266.     snd_pcm_access_t access;    /* access mode */
  267.     snd_pcm_format_t format;    /* SNDRV_PCM_FORMAT_* */
  268.     snd_pcm_subformat_t subformat;    /* subformat */
  269.     unsigned int rate;        /* rate in Hz */
  270.     unsigned int channels;        /* channels */
  271.     snd_pcm_uframes_t period_size;    /* period size */
  272.     unsigned int periods;        /* periods */
  273.     snd_pcm_uframes_t buffer_size;    /* buffer size */
  274.     unsigned int tick_time;        /* tick time */
  275.     snd_pcm_uframes_t min_align;    /* Min alignment for the format */
  276.     size_t byte_align;
  277.     unsigned int frame_bits;
  278.     unsigned int sample_bits;
  279.     unsigned int info;
  280.     unsigned int rate_num;
  281.     unsigned int rate_den;
  282.  
  283.     /* -- SW params -- */
  284.     int tstamp_mode;        /* mmap timestamp is updated */
  285.       unsigned int period_step;
  286.     unsigned int sleep_min;        /* min ticks to sleep */
  287.     snd_pcm_uframes_t xfer_align;    /* xfer size need to be a multiple */
  288.     snd_pcm_uframes_t start_threshold;
  289.     snd_pcm_uframes_t stop_threshold;
  290.     snd_pcm_uframes_t silence_threshold; /* Silence filling happens when
  291.                         noise is nearest than this */
  292.     snd_pcm_uframes_t silence_size;    /* Silence filling size */
  293.     snd_pcm_uframes_t boundary;    /* pointers wrap point */
  294.  
  295.     snd_pcm_uframes_t silence_start; /* starting pointer to silence area */
  296.     snd_pcm_uframes_t silence_filled; /* size filled with silence */
  297.  
  298.     union snd_pcm_sync_id sync;    /* hardware synchronization ID */
  299.  
  300.     /* -- mmap -- */
  301.     volatile struct snd_pcm_mmap_status *status;
  302.     volatile struct snd_pcm_mmap_control *control;
  303.  
  304.     /* -- locking / scheduling -- */
  305.     wait_queue_head_t sleep;
  306.     struct timer_list tick_timer;
  307.     struct fasync_struct *fasync;
  308.  
  309.     /* -- private section -- */
  310.     void *private_data;
  311.     void (*private_free)(struct snd_pcm_runtime *runtime);
  312.  
  313.     /* -- hardware description -- */
  314.     struct snd_pcm_hardware hw;
  315.     struct snd_pcm_hw_constraints hw_constraints;
  316.  
  317.     /* -- interrupt callbacks -- */
  318.     void (*transfer_ack_begin)(struct snd_pcm_substream *substream);
  319.     void (*transfer_ack_end)(struct snd_pcm_substream *substream);
  320.  
  321.     /* -- timer -- */
  322.     unsigned int timer_resolution;    /* timer resolution */
  323.  
  324.     /* -- DMA -- */           
  325.     unsigned char *dma_area;    /* DMA area */
  326.     dma_addr_t dma_addr;        /* physical bus address (not accessible from main CPU) */
  327.     size_t dma_bytes;        /* size of DMA area */
  328.  
  329.     struct snd_dma_buffer *dma_buffer_p;    /* allocated buffer */
  330.  
  331. #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
  332.     /* -- OSS things -- */
  333.     struct snd_pcm_oss_runtime oss;
  334. #endif
  335. };
  336.  
  337. struct snd_pcm_group {        /* keep linked substreams */
  338.     spinlock_t lock;
  339.     struct list_head substreams;
  340.     int count;
  341. };
  342.  
  343. struct snd_pcm_substream {
  344.     struct snd_pcm *pcm;
  345.     struct snd_pcm_str *pstr;
  346.     void *private_data;        /* copied from pcm->private_data */
  347.     int number;
  348.     char name[32];            /* substream name */
  349.     int stream;            /* stream (direction) */
  350.     size_t buffer_bytes_max;    /* limit ring buffer size */
  351.     struct snd_dma_buffer dma_buffer;
  352.     unsigned int dma_buf_id;
  353.     size_t dma_max;
  354.     /* -- hardware operations -- */
  355.     struct snd_pcm_ops *ops;
  356.     /* -- runtime information -- */
  357.     struct snd_pcm_runtime *runtime;
  358.         /* -- timer section -- */
  359.     struct snd_timer *timer;        /* timer */
  360.     unsigned timer_running: 1;    /* time is running */
  361.     spinlock_t timer_lock;
  362.     /* -- next substream -- */
  363.     struct snd_pcm_substream *next;
  364.     /* -- linked substreams -- */
  365.     struct list_head link_list;    /* linked list member */
  366.     struct snd_pcm_group self_group;    /* fake group for non linked substream (with substream lock inside) */
  367.     struct snd_pcm_group *group;        /* pointer to current group */
  368.     /* -- assigned files -- */
  369.     void *file;
  370.     int ref_count;
  371.     atomic_t mmap_count;
  372.     unsigned int f_flags;
  373.     void (*pcm_release)(struct snd_pcm_substream *);
  374. #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
  375.     /* -- OSS things -- */
  376.     struct snd_pcm_oss_substream oss;
  377. #endif
  378. #ifdef CONFIG_SND_VERBOSE_PROCFS
  379.     struct snd_info_entry *proc_root;
  380.     struct snd_info_entry *proc_info_entry;
  381.     struct snd_info_entry *proc_hw_params_entry;
  382.     struct snd_info_entry *proc_sw_params_entry;
  383.     struct snd_info_entry *proc_status_entry;
  384.     struct snd_info_entry *proc_prealloc_entry;
  385. #endif
  386.     /* misc flags */
  387.     unsigned int no_mmap_ctrl: 1;
  388.     unsigned int hw_opened: 1;
  389. };
  390.  
  391. #define SUBSTREAM_BUSY(substream) ((substream)->ref_count > 0)
  392.  
  393.  
  394. struct snd_pcm_str {
  395.     int stream;                /* stream (direction) */
  396.     struct snd_pcm *pcm;
  397.     /* -- substreams -- */
  398.     unsigned int substream_count;
  399.     unsigned int substream_opened;
  400.     struct snd_pcm_substream *substream;
  401. #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
  402.     /* -- OSS things -- */
  403.     struct snd_pcm_oss_stream oss;
  404. #endif
  405.     struct snd_pcm_file *files;
  406. #ifdef CONFIG_SND_VERBOSE_PROCFS
  407.     struct snd_info_entry *proc_root;
  408.     struct snd_info_entry *proc_info_entry;
  409. #ifdef CONFIG_SND_PCM_XRUN_DEBUG
  410.     unsigned int xrun_debug;    /* 0 = disabled, 1 = verbose, 2 = stacktrace */
  411.     struct snd_info_entry *proc_xrun_debug_entry;
  412. #endif
  413. #endif
  414. };
  415.  
  416. struct snd_pcm {
  417.     struct snd_card *card;
  418.     struct list_head list;
  419.     unsigned int device;    /* device number */
  420.     unsigned int info_flags;
  421.     unsigned short dev_class;
  422.     unsigned short dev_subclass;
  423.     char id[64];
  424.     char name[80];
  425.     struct snd_pcm_str streams[2];
  426.     struct mutex open_mutex;
  427.     wait_queue_head_t open_wait;
  428.     void *private_data;
  429.     void (*private_free) (struct snd_pcm *pcm);
  430. #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
  431.     struct snd_pcm_oss oss;
  432. #endif
  433. };
  434.  
  435. struct snd_pcm_notify {
  436.     int (*n_register) (struct snd_pcm * pcm);
  437.     int (*n_disconnect) (struct snd_pcm * pcm);
  438.     int (*n_unregister) (struct snd_pcm * pcm);
  439.     struct list_head list;
  440. };
  441.  
  442. /*
  443.  *  Registering
  444.  */
  445.  
  446. extern struct file_operations snd_pcm_f_ops[2];
  447.  
  448. int snd_pcm_new(struct snd_card *card, char *id, int device,
  449.         int playback_count, int capture_count,
  450.         struct snd_pcm **rpcm);
  451. int snd_pcm_new_stream(struct snd_pcm *pcm, int stream, int substream_count);
  452.  
  453. int snd_pcm_notify(struct snd_pcm_notify *notify, int nfree);
  454.  
  455. /*
  456.  *  Native I/O
  457.  */
  458.  
  459. extern rwlock_t snd_pcm_link_rwlock;
  460.  
  461. int snd_pcm_info(struct snd_pcm_substream *substream, struct snd_pcm_info *info);
  462. int snd_pcm_info_user(struct snd_pcm_substream *substream,
  463.               struct snd_pcm_info __user *info);
  464. int snd_pcm_status(struct snd_pcm_substream *substream,
  465.            struct snd_pcm_status *status);
  466. int snd_pcm_start(struct snd_pcm_substream *substream);
  467. int snd_pcm_stop(struct snd_pcm_substream *substream, int status);
  468. int snd_pcm_drain_done(struct snd_pcm_substream *substream);
  469. #ifdef CONFIG_PM
  470. int snd_pcm_suspend(struct snd_pcm_substream *substream);
  471. int snd_pcm_suspend_all(struct snd_pcm *pcm);
  472. #endif
  473. int snd_pcm_kernel_ioctl(struct snd_pcm_substream *substream, unsigned int cmd, void *arg);
  474. int snd_pcm_open_substream(struct snd_pcm *pcm, int stream, struct file *file,
  475.                struct snd_pcm_substream **rsubstream);
  476. void snd_pcm_release_substream(struct snd_pcm_substream *substream);
  477. int snd_pcm_attach_substream(struct snd_pcm *pcm, int stream, struct file *file,
  478.                  struct snd_pcm_substream **rsubstream);
  479. void snd_pcm_detach_substream(struct snd_pcm_substream *substream);
  480. void snd_pcm_vma_notify_data(void *client, void *data);
  481. int snd_pcm_mmap_data(struct snd_pcm_substream *substream, struct file *file, struct vm_area_struct *area);
  482.  
  483. #if BITS_PER_LONG >= 64
  484.  
  485. static inline void div64_32(u_int64_t *n, u_int32_t div, u_int32_t *rem)
  486. {
  487.     *rem = *n % div;
  488.     *n /= div;
  489. }
  490.  
  491. #elif defined(i386)
  492.  
  493. static inline void div64_32(u_int64_t *n, u_int32_t div, u_int32_t *rem)
  494. {
  495.     u_int32_t low, high;
  496.     low = *n & 0xffffffff;
  497.     high = *n >> 32;
  498.     if (high) {
  499.         u_int32_t high1 = high % div;
  500.         high /= div;
  501.         asm("divl %2":"=a" (low), "=d" (*rem):"rm" (div), "a" (low), "d" (high1));
  502.         *n = (u_int64_t)high << 32 | low;
  503.     } else {
  504.         *n = low / div;
  505.         *rem = low % div;
  506.     }
  507. }
  508. #else
  509.  
  510. static inline void divl(u_int32_t high, u_int32_t low,
  511.             u_int32_t div,
  512.             u_int32_t *q, u_int32_t *r)
  513. {
  514.     u_int64_t n = (u_int64_t)high << 32 | low;
  515.     u_int64_t d = (u_int64_t)div << 31;
  516.     u_int32_t q1 = 0;
  517.     int c = 32;
  518.     while (n > 0xffffffffU) {
  519.         q1 <<= 1;
  520.         if (n >= d) {
  521.             n -= d;
  522.             q1 |= 1;
  523.         }
  524.         d >>= 1;
  525.         c--;
  526.     }
  527.     q1 <<= c;
  528.     if (n) {
  529.         low = n;
  530.         *q = q1 | (low / div);
  531.         *r = low % div;
  532.     } else {
  533.         *r = 0;
  534.         *q = q1;
  535.     }
  536.     return;
  537. }
  538.  
  539. static inline void div64_32(u_int64_t *n, u_int32_t div, u_int32_t *rem)
  540. {
  541.     u_int32_t low, high;
  542.     low = *n & 0xffffffff;
  543.     high = *n >> 32;
  544.     if (high) {
  545.         u_int32_t high1 = high % div;
  546.         u_int32_t low1 = low;
  547.         high /= div;
  548.         divl(high1, low1, div, &low, rem);
  549.         *n = (u_int64_t)high << 32 | low;
  550.     } else {
  551.         *n = low / div;
  552.         *rem = low % div;
  553.     }
  554. }
  555. #endif
  556.  
  557. /*
  558.  *  PCM library
  559.  */
  560.  
  561. static inline int snd_pcm_stream_linked(struct snd_pcm_substream *substream)
  562. {
  563.     return substream->group != &substream->self_group;
  564. }
  565.  
  566. static inline void snd_pcm_stream_lock(struct snd_pcm_substream *substream)
  567. {
  568.     read_lock(&snd_pcm_link_rwlock);
  569.     spin_lock(&substream->self_group.lock);
  570. }
  571.  
  572. static inline void snd_pcm_stream_unlock(struct snd_pcm_substream *substream)
  573. {
  574.     spin_unlock(&substream->self_group.lock);
  575.     read_unlock(&snd_pcm_link_rwlock);
  576. }
  577.  
  578. static inline void snd_pcm_stream_lock_irq(struct snd_pcm_substream *substream)
  579. {
  580.     read_lock_irq(&snd_pcm_link_rwlock);
  581.     spin_lock(&substream->self_group.lock);
  582. }
  583.  
  584. static inline void snd_pcm_stream_unlock_irq(struct snd_pcm_substream *substream)
  585. {
  586.     spin_unlock(&substream->self_group.lock);
  587.     read_unlock_irq(&snd_pcm_link_rwlock);
  588. }
  589.  
  590. #define snd_pcm_stream_lock_irqsave(substream, flags) \
  591. do { \
  592.     read_lock_irqsave(&snd_pcm_link_rwlock, (flags)); \
  593.     spin_lock(&substream->self_group.lock); \
  594. } while (0)
  595.  
  596. #define snd_pcm_stream_unlock_irqrestore(substream, flags) \
  597. do { \
  598.     spin_unlock(&substream->self_group.lock); \
  599.     read_unlock_irqrestore(&snd_pcm_link_rwlock, (flags)); \
  600. } while (0)
  601.  
  602. #define snd_pcm_group_for_each(pos, substream) \
  603.     list_for_each(pos, &substream->group->substreams)
  604.  
  605. #define snd_pcm_group_substream_entry(pos) \
  606.     list_entry(pos, struct snd_pcm_substream, link_list)
  607.  
  608. static inline int snd_pcm_running(struct snd_pcm_substream *substream)
  609. {
  610.     return (substream->runtime->status->state == SNDRV_PCM_STATE_RUNNING ||
  611.         (substream->runtime->status->state == SNDRV_PCM_STATE_DRAINING &&
  612.          substream->stream == SNDRV_PCM_STREAM_PLAYBACK));
  613. }
  614.  
  615. static inline ssize_t bytes_to_samples(struct snd_pcm_runtime *runtime, ssize_t size)
  616. {
  617.     return size * 8 / runtime->sample_bits;
  618. }
  619.  
  620. static inline snd_pcm_sframes_t bytes_to_frames(struct snd_pcm_runtime *runtime, ssize_t size)
  621. {
  622.     return size * 8 / runtime->frame_bits;
  623. }
  624.  
  625. static inline ssize_t samples_to_bytes(struct snd_pcm_runtime *runtime, ssize_t size)
  626. {
  627.     return size * runtime->sample_bits / 8;
  628. }
  629.  
  630. static inline ssize_t frames_to_bytes(struct snd_pcm_runtime *runtime, snd_pcm_sframes_t size)
  631. {
  632.     return size * runtime->frame_bits / 8;
  633. }
  634.  
  635. static inline int frame_aligned(struct snd_pcm_runtime *runtime, ssize_t bytes)
  636. {
  637.     return bytes % runtime->byte_align == 0;
  638. }
  639.  
  640. static inline size_t snd_pcm_lib_buffer_bytes(struct snd_pcm_substream *substream)
  641. {
  642.     struct snd_pcm_runtime *runtime = substream->runtime;
  643.     return frames_to_bytes(runtime, runtime->buffer_size);
  644. }
  645.  
  646. static inline size_t snd_pcm_lib_period_bytes(struct snd_pcm_substream *substream)
  647. {
  648.     struct snd_pcm_runtime *runtime = substream->runtime;
  649.     return frames_to_bytes(runtime, runtime->period_size);
  650. }
  651.  
  652. /*
  653.  *  result is: 0 ... (boundary - 1)
  654.  */
  655. static inline snd_pcm_uframes_t snd_pcm_playback_avail(struct snd_pcm_runtime *runtime)
  656. {
  657.     snd_pcm_sframes_t avail = runtime->status->hw_ptr + runtime->buffer_size - runtime->control->appl_ptr;
  658.     if (avail < 0)
  659.         avail += runtime->boundary;
  660.     else if ((snd_pcm_uframes_t) avail >= runtime->boundary)
  661.         avail -= runtime->boundary;
  662.     return avail;
  663. }
  664.  
  665. /*
  666.  *  result is: 0 ... (boundary - 1)
  667.  */
  668. static inline snd_pcm_uframes_t snd_pcm_capture_avail(struct snd_pcm_runtime *runtime)
  669. {
  670.     snd_pcm_sframes_t avail = runtime->status->hw_ptr - runtime->control->appl_ptr;
  671.     if (avail < 0)
  672.         avail += runtime->boundary;
  673.     return avail;
  674. }
  675.  
  676. static inline snd_pcm_sframes_t snd_pcm_playback_hw_avail(struct snd_pcm_runtime *runtime)
  677. {
  678.     return runtime->buffer_size - snd_pcm_playback_avail(runtime);
  679. }
  680.  
  681. static inline snd_pcm_sframes_t snd_pcm_capture_hw_avail(struct snd_pcm_runtime *runtime)
  682. {
  683.     return runtime->buffer_size - snd_pcm_capture_avail(runtime);
  684. }
  685.  
  686. /**
  687.  * snd_pcm_playback_ready - check whether the playback buffer is available
  688.  * @substream: the pcm substream instance
  689.  *
  690.  * Checks whether enough free space is available on the playback buffer.
  691.  *
  692.  * Returns non-zero if available, or zero if not.
  693.  */
  694. static inline int snd_pcm_playback_ready(struct snd_pcm_substream *substream)
  695. {
  696.     struct snd_pcm_runtime *runtime = substream->runtime;
  697.     return snd_pcm_playback_avail(runtime) >= runtime->control->avail_min;
  698. }
  699.  
  700. /**
  701.  * snd_pcm_capture_ready - check whether the capture buffer is available
  702.  * @substream: the pcm substream instance
  703.  *
  704.  * Checks whether enough capture data is available on the capture buffer.
  705.  *
  706.  * Returns non-zero if available, or zero if not.
  707.  */
  708. static inline int snd_pcm_capture_ready(struct snd_pcm_substream *substream)
  709. {
  710.     struct snd_pcm_runtime *runtime = substream->runtime;
  711.     return snd_pcm_capture_avail(runtime) >= runtime->control->avail_min;
  712. }
  713.  
  714. /**
  715.  * snd_pcm_playback_data - check whether any data exists on the playback buffer
  716.  * @substream: the pcm substream instance
  717.  *
  718.  * Checks whether any data exists on the playback buffer. If stop_threshold
  719.  * is bigger or equal to boundary, then this function returns always non-zero.
  720.  *
  721.  * Returns non-zero if exists, or zero if not.
  722.  */
  723. static inline int snd_pcm_playback_data(struct snd_pcm_substream *substream)
  724. {
  725.     struct snd_pcm_runtime *runtime = substream->runtime;
  726.     
  727.     if (runtime->stop_threshold >= runtime->boundary)
  728.         return 1;
  729.     return snd_pcm_playback_avail(runtime) < runtime->buffer_size;
  730. }
  731.  
  732. /**
  733.  * snd_pcm_playback_empty - check whether the playback buffer is empty
  734.  * @substream: the pcm substream instance
  735.  *
  736.  * Checks whether the playback buffer is empty.
  737.  *
  738.  * Returns non-zero if empty, or zero if not.
  739.  */
  740. static inline int snd_pcm_playback_empty(struct snd_pcm_substream *substream)
  741. {
  742.     struct snd_pcm_runtime *runtime = substream->runtime;
  743.     return snd_pcm_playback_avail(runtime) >= runtime->buffer_size;
  744. }
  745.  
  746. /**
  747.  * snd_pcm_capture_empty - check whether the capture buffer is empty
  748.  * @substream: the pcm substream instance
  749.  *
  750.  * Checks whether the capture buffer is empty.
  751.  *
  752.  * Returns non-zero if empty, or zero if not.
  753.  */
  754. static inline int snd_pcm_capture_empty(struct snd_pcm_substream *substream)
  755. {
  756.     struct snd_pcm_runtime *runtime = substream->runtime;
  757.     return snd_pcm_capture_avail(runtime) == 0;
  758. }
  759.  
  760. static inline void snd_pcm_trigger_done(struct snd_pcm_substream *substream, 
  761.                     struct snd_pcm_substream *master)
  762. {
  763.     substream->runtime->trigger_master = master;
  764. }
  765.  
  766. static inline int hw_is_mask(int var)
  767. {
  768.     return var >= SNDRV_PCM_HW_PARAM_FIRST_MASK &&
  769.         var <= SNDRV_PCM_HW_PARAM_LAST_MASK;
  770. }
  771.  
  772. static inline int hw_is_interval(int var)
  773. {
  774.     return var >= SNDRV_PCM_HW_PARAM_FIRST_INTERVAL &&
  775.         var <= SNDRV_PCM_HW_PARAM_LAST_INTERVAL;
  776. }
  777.  
  778. static inline struct snd_mask *hw_param_mask(struct snd_pcm_hw_params *params,
  779.                      snd_pcm_hw_param_t var)
  780. {
  781.     return ¶ms->masks[var - SNDRV_PCM_HW_PARAM_FIRST_MASK];
  782. }
  783.  
  784. static inline struct snd_interval *hw_param_interval(struct snd_pcm_hw_params *params,
  785.                          snd_pcm_hw_param_t var)
  786. {
  787.     return ¶ms->intervals[var - SNDRV_PCM_HW_PARAM_FIRST_INTERVAL];
  788. }
  789.  
  790. static inline const struct snd_mask *hw_param_mask_c(const struct snd_pcm_hw_params *params,
  791.                          snd_pcm_hw_param_t var)
  792. {
  793.     return (const struct snd_mask *)hw_param_mask((struct snd_pcm_hw_params*) params, var);
  794. }
  795.  
  796. static inline const struct snd_interval *hw_param_interval_c(const struct snd_pcm_hw_params *params,
  797.                              snd_pcm_hw_param_t var)
  798. {
  799.     return (const struct snd_interval *)hw_param_interval((struct snd_pcm_hw_params*) params, var);
  800. }
  801.  
  802. #define params_access(p) snd_mask_min(hw_param_mask((p), SNDRV_PCM_HW_PARAM_ACCESS))
  803. #define params_format(p) snd_mask_min(hw_param_mask((p), SNDRV_PCM_HW_PARAM_FORMAT))
  804. #define params_subformat(p) snd_mask_min(hw_param_mask((p), SNDRV_PCM_HW_PARAM_SUBFORMAT))
  805. #define params_channels(p) hw_param_interval((p), SNDRV_PCM_HW_PARAM_CHANNELS)->min
  806. #define params_rate(p) hw_param_interval((p), SNDRV_PCM_HW_PARAM_RATE)->min
  807. #define params_period_size(p) hw_param_interval((p), SNDRV_PCM_HW_PARAM_PERIOD_SIZE)->min
  808. #define params_period_bytes(p) ((params_period_size(p)*snd_pcm_format_physical_width(params_format(p))*params_channels(p))/8)
  809. #define params_periods(p) hw_param_interval((p), SNDRV_PCM_HW_PARAM_PERIODS)->min
  810. #define params_buffer_size(p) hw_param_interval((p), SNDRV_PCM_HW_PARAM_BUFFER_SIZE)->min
  811. #define params_buffer_bytes(p) hw_param_interval((p), SNDRV_PCM_HW_PARAM_BUFFER_BYTES)->min
  812. #define params_tick_time(p) hw_param_interval((p), SNDRV_PCM_HW_PARAM_TICK_TIME)->min
  813.  
  814.  
  815. int snd_interval_refine(struct snd_interval *i, const struct snd_interval *v);
  816. void snd_interval_mul(const struct snd_interval *a, const struct snd_interval *b, struct snd_interval *c);
  817. void snd_interval_div(const struct snd_interval *a, const struct snd_interval *b, struct snd_interval *c);
  818. void snd_interval_muldivk(const struct snd_interval *a, const struct snd_interval *b, 
  819.               unsigned int k, struct snd_interval *c);
  820. void snd_interval_mulkdiv(const struct snd_interval *a, unsigned int k,
  821.               const struct snd_interval *b, struct snd_interval *c);
  822. int snd_interval_list(struct snd_interval *i, unsigned int count, unsigned int *list, unsigned int mask);
  823. int snd_interval_ratnum(struct snd_interval *i,
  824.             unsigned int rats_count, struct snd_ratnum *rats,
  825.             unsigned int *nump, unsigned int *denp);
  826.  
  827. void _snd_pcm_hw_params_any(struct snd_pcm_hw_params *params);
  828. void _snd_pcm_hw_param_setempty(struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var);
  829. int snd_pcm_hw_params_choose(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params);
  830.  
  831. int snd_pcm_hw_refine(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params);
  832.  
  833. int snd_pcm_hw_constraints_init(struct snd_pcm_substream *substream);
  834. int snd_pcm_hw_constraints_complete(struct snd_pcm_substream *substream);
  835.  
  836. int snd_pcm_hw_constraint_mask(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var,
  837.                    u_int32_t mask);
  838. int snd_pcm_hw_constraint_mask64(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var,
  839.                  u_int64_t mask);
  840. int snd_pcm_hw_constraint_minmax(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var,
  841.                  unsigned int min, unsigned int max);
  842. int snd_pcm_hw_constraint_integer(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var);
  843. int snd_pcm_hw_constraint_list(struct snd_pcm_runtime *runtime, 
  844.                    unsigned int cond,
  845.                    snd_pcm_hw_param_t var,
  846.                    struct snd_pcm_hw_constraint_list *l);
  847. int snd_pcm_hw_constraint_ratnums(struct snd_pcm_runtime *runtime, 
  848.                   unsigned int cond,
  849.                   snd_pcm_hw_param_t var,
  850.                   struct snd_pcm_hw_constraint_ratnums *r);
  851. int snd_pcm_hw_constraint_ratdens(struct snd_pcm_runtime *runtime, 
  852.                   unsigned int cond,
  853.                   snd_pcm_hw_param_t var,
  854.                   struct snd_pcm_hw_constraint_ratdens *r);
  855. int snd_pcm_hw_constraint_msbits(struct snd_pcm_runtime *runtime, 
  856.                  unsigned int cond,
  857.                  unsigned int width,
  858.                  unsigned int msbits);
  859. int snd_pcm_hw_constraint_step(struct snd_pcm_runtime *runtime,
  860.                    unsigned int cond,
  861.                    snd_pcm_hw_param_t var,
  862.                    unsigned long step);
  863. int snd_pcm_hw_constraint_pow2(struct snd_pcm_runtime *runtime,
  864.                    unsigned int cond,
  865.                    snd_pcm_hw_param_t var);
  866. int snd_pcm_hw_rule_add(struct snd_pcm_runtime *runtime,
  867.             unsigned int cond,
  868.             int var,
  869.             snd_pcm_hw_rule_func_t func, void *private,
  870.             int dep, ...);
  871.  
  872. int snd_pcm_format_signed(snd_pcm_format_t format);
  873. int snd_pcm_format_unsigned(snd_pcm_format_t format);
  874. int snd_pcm_format_linear(snd_pcm_format_t format);
  875. int snd_pcm_format_little_endian(snd_pcm_format_t format);
  876. int snd_pcm_format_big_endian(snd_pcm_format_t format);
  877. #if 0 /* just for DocBook */
  878. /**
  879.  * snd_pcm_format_cpu_endian - Check the PCM format is CPU-endian
  880.  * @format: the format to check
  881.  *
  882.  * Returns 1 if the given PCM format is CPU-endian, 0 if
  883.  * opposite, or a negative error code if endian not specified.
  884.  */
  885. int snd_pcm_format_cpu_endian(snd_pcm_format_t format);
  886. #endif /* DocBook */
  887. #ifdef SNDRV_LITTLE_ENDIAN
  888. #define snd_pcm_format_cpu_endian(format) snd_pcm_format_little_endian(format)
  889. #else
  890. #define snd_pcm_format_cpu_endian(format) snd_pcm_format_big_endian(format)
  891. #endif
  892. int snd_pcm_format_width(snd_pcm_format_t format);            /* in bits */
  893. int snd_pcm_format_physical_width(snd_pcm_format_t format);        /* in bits */
  894. ssize_t snd_pcm_format_size(snd_pcm_format_t format, size_t samples);
  895. const unsigned char *snd_pcm_format_silence_64(snd_pcm_format_t format);
  896. int snd_pcm_format_set_silence(snd_pcm_format_t format, void *buf, unsigned int frames);
  897. snd_pcm_format_t snd_pcm_build_linear_format(int width, int unsignd, int big_endian);
  898.  
  899. void snd_pcm_set_ops(struct snd_pcm * pcm, int direction, struct snd_pcm_ops *ops);
  900. void snd_pcm_set_sync(struct snd_pcm_substream *substream);
  901. int snd_pcm_lib_interleave_len(struct snd_pcm_substream *substream);
  902. int snd_pcm_lib_ioctl(struct snd_pcm_substream *substream,
  903.               unsigned int cmd, void *arg);                      
  904. int snd_pcm_update_hw_ptr(struct snd_pcm_substream *substream);
  905. int snd_pcm_playback_xrun_check(struct snd_pcm_substream *substream);
  906. int snd_pcm_capture_xrun_check(struct snd_pcm_substream *substream);
  907. int snd_pcm_playback_xrun_asap(struct snd_pcm_substream *substream);
  908. int snd_pcm_capture_xrun_asap(struct snd_pcm_substream *substream);
  909. void snd_pcm_playback_silence(struct snd_pcm_substream *substream, snd_pcm_uframes_t new_hw_ptr);
  910. void snd_pcm_tick_prepare(struct snd_pcm_substream *substream);
  911. void snd_pcm_tick_set(struct snd_pcm_substream *substream, unsigned long ticks);
  912. void snd_pcm_tick_elapsed(struct snd_pcm_substream *substream);
  913. void snd_pcm_period_elapsed(struct snd_pcm_substream *substream);
  914. snd_pcm_sframes_t snd_pcm_lib_write(struct snd_pcm_substream *substream,
  915.                     const void __user *buf,
  916.                     snd_pcm_uframes_t frames);
  917. snd_pcm_sframes_t snd_pcm_lib_read(struct snd_pcm_substream *substream,
  918.                    void __user *buf, snd_pcm_uframes_t frames);
  919. snd_pcm_sframes_t snd_pcm_lib_writev(struct snd_pcm_substream *substream,
  920.                      void __user **bufs, snd_pcm_uframes_t frames);
  921. snd_pcm_sframes_t snd_pcm_lib_readv(struct snd_pcm_substream *substream,
  922.                     void __user **bufs, snd_pcm_uframes_t frames);
  923.  
  924. int snd_pcm_limit_hw_rates(struct snd_pcm_runtime *runtime);
  925.  
  926. static inline void snd_pcm_set_runtime_buffer(struct snd_pcm_substream *substream,
  927.                           struct snd_dma_buffer *bufp)
  928. {
  929.     struct snd_pcm_runtime *runtime = substream->runtime;
  930.     if (bufp) {
  931.         runtime->dma_buffer_p = bufp;
  932.         runtime->dma_area = bufp->area;
  933.         runtime->dma_addr = bufp->addr;
  934.         runtime->dma_bytes = bufp->bytes;
  935.     } else {
  936.         runtime->dma_buffer_p = NULL;
  937.         runtime->dma_area = NULL;
  938.         runtime->dma_addr = 0;
  939.         runtime->dma_bytes = 0;
  940.     }
  941. }
  942.  
  943. /*
  944.  *  Timer interface
  945.  */
  946.  
  947. void snd_pcm_timer_resolution_change(struct snd_pcm_substream *substream);
  948. void snd_pcm_timer_init(struct snd_pcm_substream *substream);
  949. void snd_pcm_timer_done(struct snd_pcm_substream *substream);
  950.  
  951. /*
  952.  *  Memory
  953.  */
  954.  
  955. int snd_pcm_lib_preallocate_free(struct snd_pcm_substream *substream);
  956. int snd_pcm_lib_preallocate_free_for_all(struct snd_pcm *pcm);
  957. int snd_pcm_lib_preallocate_pages(struct snd_pcm_substream *substream,
  958.                   int type, struct device *data,
  959.                   size_t size, size_t max);
  960. int snd_pcm_lib_preallocate_pages_for_all(struct snd_pcm *pcm,
  961.                       int type, void *data,
  962.                       size_t size, size_t max);
  963. int snd_pcm_lib_malloc_pages(struct snd_pcm_substream *substream, size_t size);
  964. int snd_pcm_lib_free_pages(struct snd_pcm_substream *substream);
  965.  
  966. #define snd_pcm_substream_sgbuf(substream) ((substream)->runtime->dma_buffer_p->private_data)
  967. #define snd_pcm_sgbuf_pages(size) snd_sgbuf_aligned_pages(size)
  968. #define snd_pcm_sgbuf_get_addr(sgbuf,ofs) snd_sgbuf_get_addr(sgbuf,ofs)
  969. struct page *snd_pcm_sgbuf_ops_page(struct snd_pcm_substream *substream, unsigned long offset);
  970.  
  971. /* handle mmap counter - PCM mmap callback should handle this counter properly */
  972. static inline void snd_pcm_mmap_data_open(struct vm_area_struct *area)
  973. {
  974.     struct snd_pcm_substream *substream = (struct snd_pcm_substream *)area->vm_private_data;
  975.     atomic_inc(&substream->mmap_count);
  976. }
  977.  
  978. static inline void snd_pcm_mmap_data_close(struct vm_area_struct *area)
  979. {
  980.     struct snd_pcm_substream *substream = (struct snd_pcm_substream *)area->vm_private_data;
  981.     atomic_dec(&substream->mmap_count);
  982. }
  983.  
  984. /* mmap for io-memory area */
  985. #if defined(CONFIG_X86) || defined(CONFIG_PPC) || defined(CONFIG_ALPHA)
  986. #define SNDRV_PCM_INFO_MMAP_IOMEM    SNDRV_PCM_INFO_MMAP
  987. int snd_pcm_lib_mmap_iomem(struct snd_pcm_substream *substream, struct vm_area_struct *area);
  988. #else
  989. #define SNDRV_PCM_INFO_MMAP_IOMEM    0
  990. #define snd_pcm_lib_mmap_iomem    NULL
  991. #endif
  992.  
  993. static inline void snd_pcm_limit_isa_dma_size(int dma, size_t *max)
  994. {
  995.     *max = dma < 4 ? 64 * 1024 : 128 * 1024;
  996. }
  997.  
  998. /*
  999.  *  Misc
  1000.  */
  1001.  
  1002. #define SNDRV_PCM_DEFAULT_CON_SPDIF    (IEC958_AES0_CON_EMPHASIS_NONE|\
  1003.                      (IEC958_AES1_CON_ORIGINAL<<8)|\
  1004.                      (IEC958_AES1_CON_PCM_CODER<<8)|\
  1005.                      (IEC958_AES3_CON_FS_48000<<24))
  1006.  
  1007. #endif /* __SOUND_PCM_H */
  1008.