pcm.h 35 KB

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