Skip to content

C
clone-Linux

gsplhtlxg / clone-Linux

通知 2
Star 0
Fork 1
C
clone-Linux

体验新版 GitCode，发现更多精彩内容 >>

提交 877211f5 编写于 作者: T Takashi Iwai 提交者： Jaroslav Kysela
浏览文件
操作

[ALSA] Remove xxx_t typedefs: PCM 

Modules: PCM Midlevel

Remove xxx_t typedefs from the core PCM codes.
Signed-off-by: NTakashi Iwai <tiwai@suse.de>
上级 24c1f931
展开全部 显示空白变更内容
内联 并排
Showing with 983 addition and 952 deletion
include/sound/pcm-indirect.h
浏览文件 @ 877211f5
...@@ -24,7 +24,7 @@ ...@@ -24,7 +24,7 @@
#include <sound/pcm.h> #include <sound/pcm.h>
typedef struct sndrv_pcm_indirect { struct snd_pcm_indirect {
unsigned int hw_buffer_size; /* Byte size of hardware buffer */ unsigned int hw_buffer_size; /* Byte size of hardware buffer */
unsigned int hw_queue_size; /* Max queue size of hw buffer (0 = buffer size) */ unsigned int hw_queue_size; /* Max queue size of hw buffer (0 = buffer size) */
unsigned int hw_data; /* Offset to next dst (or src) in hw ring buffer */ unsigned int hw_data; /* Offset to next dst (or src) in hw ring buffer */
...@@ -35,20 +35,20 @@ typedef struct sndrv_pcm_indirect { ...@@ -35,20 +35,20 @@ typedef struct sndrv_pcm_indirect {
unsigned int sw_io; /* Current software pointer in bytes */ unsigned int sw_io; /* Current software pointer in bytes */
int sw_ready; /* Bytes ready to be transferred to/from hw */ int sw_ready; /* Bytes ready to be transferred to/from hw */
snd_pcm_uframes_t appl_ptr; /* Last seen appl_ptr */ snd_pcm_uframes_t appl_ptr; /* Last seen appl_ptr */
} snd_pcm_indirect_t; };
typedef void (*snd_pcm_indirect_copy_t)(snd_pcm_substream_t *substream, typedef void (*snd_pcm_indirect_copy_t)(struct snd_pcm_substream *substream,
snd_pcm_indirect_t *rec, size_t bytes); struct snd_pcm_indirect *rec, size_t bytes);
/* /*
* helper function for playback ack callback * helper function for playback ack callback
*/ */
static inline void static inline void
snd_pcm_indirect_playback_transfer(snd_pcm_substream_t *substream, snd_pcm_indirect_playback_transfer(struct snd_pcm_substream *substream,
snd_pcm_indirect_t *rec, struct snd_pcm_indirect *rec,
snd_pcm_indirect_copy_t copy) snd_pcm_indirect_copy_t copy)
{ {
snd_pcm_runtime_t *runtime = substream->runtime; struct snd_pcm_runtime *runtime = substream->runtime;
snd_pcm_uframes_t appl_ptr = runtime->control->appl_ptr; snd_pcm_uframes_t appl_ptr = runtime->control->appl_ptr;
snd_pcm_sframes_t diff = appl_ptr - rec->appl_ptr; snd_pcm_sframes_t diff = appl_ptr - rec->appl_ptr;
int qsize; int qsize;
...@@ -89,8 +89,8 @@ snd_pcm_indirect_playback_transfer(snd_pcm_substream_t *substream, ...@@ -89,8 +89,8 @@ snd_pcm_indirect_playback_transfer(snd_pcm_substream_t *substream,
* ptr = current byte pointer * ptr = current byte pointer
*/ */
static inline snd_pcm_uframes_t static inline snd_pcm_uframes_t
snd_pcm_indirect_playback_pointer(snd_pcm_substream_t *substream, snd_pcm_indirect_playback_pointer(struct snd_pcm_substream *substream,
snd_pcm_indirect_t *rec, unsigned int ptr) struct snd_pcm_indirect *rec, unsigned int ptr)
{ {
int bytes = ptr - rec->hw_io; int bytes = ptr - rec->hw_io;
if (bytes < 0) if (bytes < 0)
...@@ -110,11 +110,11 @@ snd_pcm_indirect_playback_pointer(snd_pcm_substream_t *substream, ...@@ -110,11 +110,11 @@ snd_pcm_indirect_playback_pointer(snd_pcm_substream_t *substream,
* helper function for capture ack callback * helper function for capture ack callback
*/ */
static inline void static inline void
snd_pcm_indirect_capture_transfer(snd_pcm_substream_t *substream, snd_pcm_indirect_capture_transfer(struct snd_pcm_substream *substream,
snd_pcm_indirect_t *rec, struct snd_pcm_indirect *rec,
snd_pcm_indirect_copy_t copy) snd_pcm_indirect_copy_t copy)
{ {
snd_pcm_runtime_t *runtime = substream->runtime; struct snd_pcm_runtime *runtime = substream->runtime;
snd_pcm_uframes_t appl_ptr = runtime->control->appl_ptr; snd_pcm_uframes_t appl_ptr = runtime->control->appl_ptr;
snd_pcm_sframes_t diff = appl_ptr - rec->appl_ptr; snd_pcm_sframes_t diff = appl_ptr - rec->appl_ptr;
...@@ -154,8 +154,8 @@ snd_pcm_indirect_capture_transfer(snd_pcm_substream_t *substream, ...@@ -154,8 +154,8 @@ snd_pcm_indirect_capture_transfer(snd_pcm_substream_t *substream,
* ptr = current byte pointer * ptr = current byte pointer
*/ */
static inline snd_pcm_uframes_t static inline snd_pcm_uframes_t
snd_pcm_indirect_capture_pointer(snd_pcm_substream_t *substream, snd_pcm_indirect_capture_pointer(struct snd_pcm_substream *substream,
snd_pcm_indirect_t *rec, unsigned int ptr) struct snd_pcm_indirect *rec, unsigned int ptr)
{ {
int qsize; int qsize;
int bytes = ptr - rec->hw_io; int bytes = ptr - rec->hw_io;
......
include/sound/pcm.h
浏览文件 @ 877211f5
此差异已折叠。
include/sound/pcm_params.h
浏览文件 @ 877211f5
...@@ -22,17 +22,17 @@ ...@@ -22,17 +22,17 @@
* *
*/ */
extern int snd_pcm_hw_param_mask(snd_pcm_substream_t *pcm, snd_pcm_hw_params_t *params, extern int snd_pcm_hw_param_mask(struct snd_pcm_substream *pcm, struct snd_pcm_hw_params *params,
snd_pcm_hw_param_t var, const snd_mask_t *val); snd_pcm_hw_param_t var, const struct snd_mask *val);
extern unsigned int snd_pcm_hw_param_value_min(const snd_pcm_hw_params_t *params, extern unsigned int snd_pcm_hw_param_value_min(const struct snd_pcm_hw_params *params,
snd_pcm_hw_param_t var, int *dir); snd_pcm_hw_param_t var, int *dir);
extern unsigned int snd_pcm_hw_param_value_max(const snd_pcm_hw_params_t *params, extern unsigned int snd_pcm_hw_param_value_max(const struct snd_pcm_hw_params *params,
snd_pcm_hw_param_t var, int *dir); snd_pcm_hw_param_t var, int *dir);
extern int _snd_pcm_hw_param_min(snd_pcm_hw_params_t *params, extern int _snd_pcm_hw_param_min(struct snd_pcm_hw_params *params,
snd_pcm_hw_param_t var, unsigned int val, int dir); snd_pcm_hw_param_t var, unsigned int val, int dir);
extern int _snd_pcm_hw_param_setinteger(snd_pcm_hw_params_t *params, extern int _snd_pcm_hw_param_setinteger(struct snd_pcm_hw_params *params,
snd_pcm_hw_param_t var); snd_pcm_hw_param_t var);
extern int _snd_pcm_hw_param_set(snd_pcm_hw_params_t *params, extern int _snd_pcm_hw_param_set(struct snd_pcm_hw_params *params,
snd_pcm_hw_param_t var, unsigned int val, int dir); snd_pcm_hw_param_t var, unsigned int val, int dir);
/* To share the same code we have alsa-lib */ /* To share the same code we have alsa-lib */
...@@ -71,20 +71,20 @@ INLINE unsigned int ld2(u_int32_t v) ...@@ -71,20 +71,20 @@ INLINE unsigned int ld2(u_int32_t v)
INLINE size_t snd_mask_sizeof(void) INLINE size_t snd_mask_sizeof(void)
{ {
return sizeof(snd_mask_t); return sizeof(struct snd_mask);
} }
INLINE void snd_mask_none(snd_mask_t *mask) INLINE void snd_mask_none(struct snd_mask *mask)
{ {
memset(mask, 0, sizeof(*mask)); memset(mask, 0, sizeof(*mask));
} }
INLINE void snd_mask_any(snd_mask_t *mask) INLINE void snd_mask_any(struct snd_mask *mask)
{ {
memset(mask, 0xff, SNDRV_MASK_SIZE * sizeof(u_int32_t)); memset(mask, 0xff, SNDRV_MASK_SIZE * sizeof(u_int32_t));
} }
INLINE int snd_mask_empty(const snd_mask_t *mask) INLINE int snd_mask_empty(const struct snd_mask *mask)
{ {
int i; int i;
for (i = 0; i < SNDRV_MASK_SIZE; i++) for (i = 0; i < SNDRV_MASK_SIZE; i++)
...@@ -93,7 +93,7 @@ INLINE int snd_mask_empty(const snd_mask_t *mask) ...@@ -93,7 +93,7 @@ INLINE int snd_mask_empty(const snd_mask_t *mask)
return 1; return 1;
} }
INLINE unsigned int snd_mask_min(const snd_mask_t *mask) INLINE unsigned int snd_mask_min(const struct snd_mask *mask)
{ {
int i; int i;
assert(!snd_mask_empty(mask)); assert(!snd_mask_empty(mask));
...@@ -104,7 +104,7 @@ INLINE unsigned int snd_mask_min(const snd_mask_t *mask) ...@@ -104,7 +104,7 @@ INLINE unsigned int snd_mask_min(const snd_mask_t *mask)
return 0; return 0;
} }
INLINE unsigned int snd_mask_max(const snd_mask_t *mask) INLINE unsigned int snd_mask_max(const struct snd_mask *mask)
{ {
int i; int i;
assert(!snd_mask_empty(mask)); assert(!snd_mask_empty(mask));
...@@ -115,19 +115,19 @@ INLINE unsigned int snd_mask_max(const snd_mask_t *mask) ...@@ -115,19 +115,19 @@ INLINE unsigned int snd_mask_max(const snd_mask_t *mask)
return 0; return 0;
} }
INLINE void snd_mask_set(snd_mask_t *mask, unsigned int val) INLINE void snd_mask_set(struct snd_mask *mask, unsigned int val)
{ {
assert(val <= SNDRV_MASK_BITS); assert(val <= SNDRV_MASK_BITS);
mask->bits[MASK_OFS(val)] |= MASK_BIT(val); mask->bits[MASK_OFS(val)] |= MASK_BIT(val);
} }
INLINE void snd_mask_reset(snd_mask_t *mask, unsigned int val) INLINE void snd_mask_reset(struct snd_mask *mask, unsigned int val)
{ {
assert(val <= SNDRV_MASK_BITS); assert(val <= SNDRV_MASK_BITS);
mask->bits[MASK_OFS(val)] &= ~MASK_BIT(val); mask->bits[MASK_OFS(val)] &= ~MASK_BIT(val);
} }
INLINE void snd_mask_set_range(snd_mask_t *mask, unsigned int from, unsigned int to) INLINE void snd_mask_set_range(struct snd_mask *mask, unsigned int from, unsigned int to)
{ {
unsigned int i; unsigned int i;
assert(to <= SNDRV_MASK_BITS && from <= to); assert(to <= SNDRV_MASK_BITS && from <= to);
...@@ -135,7 +135,7 @@ INLINE void snd_mask_set_range(snd_mask_t *mask, unsigned int from, unsigned int ...@@ -135,7 +135,7 @@ INLINE void snd_mask_set_range(snd_mask_t *mask, unsigned int from, unsigned int
mask->bits[MASK_OFS(i)] |= MASK_BIT(i); mask->bits[MASK_OFS(i)] |= MASK_BIT(i);
} }
INLINE void snd_mask_reset_range(snd_mask_t *mask, unsigned int from, unsigned int to) INLINE void snd_mask_reset_range(struct snd_mask *mask, unsigned int from, unsigned int to)
{ {
unsigned int i; unsigned int i;
assert(to <= SNDRV_MASK_BITS && from <= to); assert(to <= SNDRV_MASK_BITS && from <= to);
...@@ -143,7 +143,7 @@ INLINE void snd_mask_reset_range(snd_mask_t *mask, unsigned int from, unsigned i ...@@ -143,7 +143,7 @@ INLINE void snd_mask_reset_range(snd_mask_t *mask, unsigned int from, unsigned i
mask->bits[MASK_OFS(i)] &= ~MASK_BIT(i); mask->bits[MASK_OFS(i)] &= ~MASK_BIT(i);
} }
INLINE void snd_mask_leave(snd_mask_t *mask, unsigned int val) INLINE void snd_mask_leave(struct snd_mask *mask, unsigned int val)
{ {
unsigned int v; unsigned int v;
assert(val <= SNDRV_MASK_BITS); assert(val <= SNDRV_MASK_BITS);
...@@ -152,30 +152,30 @@ INLINE void snd_mask_leave(snd_mask_t *mask, unsigned int val) ...@@ -152,30 +152,30 @@ INLINE void snd_mask_leave(snd_mask_t *mask, unsigned int val)
mask->bits[MASK_OFS(val)] = v; mask->bits[MASK_OFS(val)] = v;
} }
INLINE void snd_mask_intersect(snd_mask_t *mask, const snd_mask_t *v) INLINE void snd_mask_intersect(struct snd_mask *mask, const struct snd_mask *v)
{ {
int i; int i;
for (i = 0; i < SNDRV_MASK_SIZE; i++) for (i = 0; i < SNDRV_MASK_SIZE; i++)
mask->bits[i] &= v->bits[i]; mask->bits[i] &= v->bits[i];
} }
INLINE int snd_mask_eq(const snd_mask_t *mask, const snd_mask_t *v) INLINE int snd_mask_eq(const struct snd_mask *mask, const struct snd_mask *v)
{ {
return ! memcmp(mask, v, SNDRV_MASK_SIZE * sizeof(u_int32_t)); return ! memcmp(mask, v, SNDRV_MASK_SIZE * sizeof(u_int32_t));
} }
INLINE void snd_mask_copy(snd_mask_t *mask, const snd_mask_t *v) INLINE void snd_mask_copy(struct snd_mask *mask, const struct snd_mask *v)
{ {
*mask = *v; *mask = *v;
} }
INLINE int snd_mask_test(const snd_mask_t *mask, unsigned int val) INLINE int snd_mask_test(const struct snd_mask *mask, unsigned int val)
{ {
assert(val <= SNDRV_MASK_BITS); assert(val <= SNDRV_MASK_BITS);
return mask->bits[MASK_OFS(val)] & MASK_BIT(val); return mask->bits[MASK_OFS(val)] & MASK_BIT(val);
} }
INLINE int snd_mask_single(const snd_mask_t *mask) INLINE int snd_mask_single(const struct snd_mask *mask)
{ {
int i, c = 0; int i, c = 0;
assert(!snd_mask_empty(mask)); assert(!snd_mask_empty(mask));
...@@ -191,9 +191,9 @@ INLINE int snd_mask_single(const snd_mask_t *mask) ...@@ -191,9 +191,9 @@ INLINE int snd_mask_single(const snd_mask_t *mask)
return 1; return 1;
} }
INLINE int snd_mask_refine(snd_mask_t *mask, const snd_mask_t *v) INLINE int snd_mask_refine(struct snd_mask *mask, const struct snd_mask *v)
{ {
snd_mask_t old; struct snd_mask old;
assert(!snd_mask_empty(mask)); assert(!snd_mask_empty(mask));
snd_mask_copy(&old, mask); snd_mask_copy(&old, mask);
snd_mask_intersect(mask, v); snd_mask_intersect(mask, v);
...@@ -202,7 +202,7 @@ INLINE int snd_mask_refine(snd_mask_t *mask, const snd_mask_t *v) ...@@ -202,7 +202,7 @@ INLINE int snd_mask_refine(snd_mask_t *mask, const snd_mask_t *v)
return !snd_mask_eq(mask, &old); return !snd_mask_eq(mask, &old);
} }
INLINE int snd_mask_refine_first(snd_mask_t *mask) INLINE int snd_mask_refine_first(struct snd_mask *mask)
{ {
assert(!snd_mask_empty(mask)); assert(!snd_mask_empty(mask));
if (snd_mask_single(mask)) if (snd_mask_single(mask))
...@@ -211,7 +211,7 @@ INLINE int snd_mask_refine_first(snd_mask_t *mask) ...@@ -211,7 +211,7 @@ INLINE int snd_mask_refine_first(snd_mask_t *mask)
return 1; return 1;
} }
INLINE int snd_mask_refine_last(snd_mask_t *mask) INLINE int snd_mask_refine_last(struct snd_mask *mask)
{ {
assert(!snd_mask_empty(mask)); assert(!snd_mask_empty(mask));
if (snd_mask_single(mask)) if (snd_mask_single(mask))
...@@ -220,7 +220,7 @@ INLINE int snd_mask_refine_last(snd_mask_t *mask) ...@@ -220,7 +220,7 @@ INLINE int snd_mask_refine_last(snd_mask_t *mask)
return 1; return 1;
} }
INLINE int snd_mask_refine_min(snd_mask_t *mask, unsigned int val) INLINE int snd_mask_refine_min(struct snd_mask *mask, unsigned int val)
{ {
assert(!snd_mask_empty(mask)); assert(!snd_mask_empty(mask));
if (snd_mask_min(mask) >= val) if (snd_mask_min(mask) >= val)
...@@ -231,7 +231,7 @@ INLINE int snd_mask_refine_min(snd_mask_t *mask, unsigned int val) ...@@ -231,7 +231,7 @@ INLINE int snd_mask_refine_min(snd_mask_t *mask, unsigned int val)
return 1; return 1;
} }
INLINE int snd_mask_refine_max(snd_mask_t *mask, unsigned int val) INLINE int snd_mask_refine_max(struct snd_mask *mask, unsigned int val)
{ {
assert(!snd_mask_empty(mask)); assert(!snd_mask_empty(mask));
if (snd_mask_max(mask) <= val) if (snd_mask_max(mask) <= val)
...@@ -242,7 +242,7 @@ INLINE int snd_mask_refine_max(snd_mask_t *mask, unsigned int val) ...@@ -242,7 +242,7 @@ INLINE int snd_mask_refine_max(snd_mask_t *mask, unsigned int val)
return 1; return 1;
} }
INLINE int snd_mask_refine_set(snd_mask_t *mask, unsigned int val) INLINE int snd_mask_refine_set(struct snd_mask *mask, unsigned int val)
{ {
int changed; int changed;
assert(!snd_mask_empty(mask)); assert(!snd_mask_empty(mask));
...@@ -253,13 +253,13 @@ INLINE int snd_mask_refine_set(snd_mask_t *mask, unsigned int val) ...@@ -253,13 +253,13 @@ INLINE int snd_mask_refine_set(snd_mask_t *mask, unsigned int val)
return changed; return changed;
} }
INLINE int snd_mask_value(const snd_mask_t *mask) INLINE int snd_mask_value(const struct snd_mask *mask)
{ {
assert(!snd_mask_empty(mask)); assert(!snd_mask_empty(mask));
return snd_mask_min(mask); return snd_mask_min(mask);
} }
INLINE void snd_interval_any(snd_interval_t *i) INLINE void snd_interval_any(struct snd_interval *i)
{ {
i->min = 0; i->min = 0;
i->openmin = 0; i->openmin = 0;
...@@ -269,42 +269,42 @@ INLINE void snd_interval_any(snd_interval_t *i) ...@@ -269,42 +269,42 @@ INLINE void snd_interval_any(snd_interval_t *i)
i->empty = 0; i->empty = 0;
} }
INLINE void snd_interval_none(snd_interval_t *i) INLINE void snd_interval_none(struct snd_interval *i)
{ {
i->empty = 1; i->empty = 1;
} }
INLINE int snd_interval_checkempty(const snd_interval_t *i) INLINE int snd_interval_checkempty(const struct snd_interval *i)
{ {
return (i->min > i->max || return (i->min > i->max ||
(i->min == i->max && (i->openmin || i->openmax))); (i->min == i->max && (i->openmin || i->openmax)));
} }
INLINE int snd_interval_empty(const snd_interval_t *i) INLINE int snd_interval_empty(const struct snd_interval *i)
{ {
return i->empty; return i->empty;
} }
INLINE int snd_interval_single(const snd_interval_t *i) INLINE int snd_interval_single(const struct snd_interval *i)
{ {
assert(!snd_interval_empty(i)); assert(!snd_interval_empty(i));
return (i->min == i->max || return (i->min == i->max ||
(i->min + 1 == i->max && i->openmax)); (i->min + 1 == i->max && i->openmax));
} }
INLINE int snd_interval_value(const snd_interval_t *i) INLINE int snd_interval_value(const struct snd_interval *i)
{ {
assert(snd_interval_single(i)); assert(snd_interval_single(i));
return i->min; return i->min;
} }
INLINE int snd_interval_min(const snd_interval_t *i) INLINE int snd_interval_min(const struct snd_interval *i)
{ {
assert(!snd_interval_empty(i)); assert(!snd_interval_empty(i));
return i->min; return i->min;
} }
INLINE int snd_interval_max(const snd_interval_t *i) INLINE int snd_interval_max(const struct snd_interval *i)
{ {
unsigned int v; unsigned int v;
assert(!snd_interval_empty(i)); assert(!snd_interval_empty(i));
...@@ -314,18 +314,18 @@ INLINE int snd_interval_max(const snd_interval_t *i) ...@@ -314,18 +314,18 @@ INLINE int snd_interval_max(const snd_interval_t *i)
return v; return v;
} }
INLINE int snd_interval_test(const snd_interval_t *i, unsigned int val) INLINE int snd_interval_test(const struct snd_interval *i, unsigned int val)
{ {
return !((i->min > val || (i->min == val && i->openmin) || return !((i->min > val || (i->min == val && i->openmin) ||
i->max < val || (i->max == val && i->openmax))); i->max < val || (i->max == val && i->openmax)));
} }
INLINE void snd_interval_copy(snd_interval_t *d, const snd_interval_t *s) INLINE void snd_interval_copy(struct snd_interval *d, const struct snd_interval *s)
{ {
*d = *s; *d = *s;
} }
INLINE int snd_interval_setinteger(snd_interval_t *i) INLINE int snd_interval_setinteger(struct snd_interval *i)
{ {
if (i->integer) if (i->integer)
return 0; return 0;
...@@ -335,7 +335,7 @@ INLINE int snd_interval_setinteger(snd_interval_t *i) ...@@ -335,7 +335,7 @@ INLINE int snd_interval_setinteger(snd_interval_t *i)
return 1; return 1;
} }
INLINE int snd_interval_eq(const snd_interval_t *i1, const snd_interval_t *i2) INLINE int snd_interval_eq(const struct snd_interval *i1, const struct snd_interval *i2)
{ {
if (i1->empty) if (i1->empty)
return i2->empty; return i2->empty;
......
sound/core/pcm.c
浏览文件 @ 877211f5
...@@ -33,18 +33,18 @@ MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>, Abramo Bagnara <abramo@alsa-proj ...@@ -33,18 +33,18 @@ MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>, Abramo Bagnara <abramo@alsa-proj
MODULE_DESCRIPTION("Midlevel PCM code for ALSA."); MODULE_DESCRIPTION("Midlevel PCM code for ALSA.");
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");
snd_pcm_t *snd_pcm_devices[SNDRV_CARDS * SNDRV_PCM_DEVICES]; struct snd_pcm *snd_pcm_devices[SNDRV_CARDS * SNDRV_PCM_DEVICES];
static LIST_HEAD(snd_pcm_notify_list); static LIST_HEAD(snd_pcm_notify_list);
static DECLARE_MUTEX(register_mutex); static DECLARE_MUTEX(register_mutex);
static int snd_pcm_free(snd_pcm_t *pcm); static int snd_pcm_free(struct snd_pcm *pcm);
static int snd_pcm_dev_free(snd_device_t *device); static int snd_pcm_dev_free(struct snd_device *device);
static int snd_pcm_dev_register(snd_device_t *device); static int snd_pcm_dev_register(struct snd_device *device);
static int snd_pcm_dev_disconnect(snd_device_t *device); static int snd_pcm_dev_disconnect(struct snd_device *device);
static int snd_pcm_dev_unregister(snd_device_t *device); static int snd_pcm_dev_unregister(struct snd_device *device);
static int snd_pcm_control_ioctl(snd_card_t * card, static int snd_pcm_control_ioctl(struct snd_card *card,
snd_ctl_file_t * control, struct snd_ctl_file *control,
unsigned int cmd, unsigned long arg) unsigned int cmd, unsigned long arg)
{ {
unsigned int tmp; unsigned int tmp;
...@@ -71,13 +71,13 @@ static int snd_pcm_control_ioctl(snd_card_t * card, ...@@ -71,13 +71,13 @@ static int snd_pcm_control_ioctl(snd_card_t * card,
} }
case SNDRV_CTL_IOCTL_PCM_INFO: case SNDRV_CTL_IOCTL_PCM_INFO:
{ {
snd_pcm_info_t __user *info; struct snd_pcm_info __user *info;
unsigned int device, subdevice; unsigned int device, subdevice;
snd_pcm_stream_t stream; int stream;
snd_pcm_t *pcm; struct snd_pcm *pcm;
snd_pcm_str_t *pstr; struct snd_pcm_str *pstr;
snd_pcm_substream_t *substream; struct snd_pcm_substream *substream;
info = (snd_pcm_info_t __user *)arg; info = (struct snd_pcm_info __user *)arg;
if (get_user(device, &info->device)) if (get_user(device, &info->device))
return -EFAULT; return -EFAULT;
if (device >= SNDRV_PCM_DEVICES) if (device >= SNDRV_PCM_DEVICES)
...@@ -200,7 +200,7 @@ static char *snd_pcm_tstamp_mode_names[] = { ...@@ -200,7 +200,7 @@ static char *snd_pcm_tstamp_mode_names[] = {
TSTAMP(MMAP), TSTAMP(MMAP),
}; };
static const char *snd_pcm_stream_name(snd_pcm_stream_t stream) static const char *snd_pcm_stream_name(int stream)
{ {
snd_assert(stream <= SNDRV_PCM_STREAM_LAST, return NULL); snd_assert(stream <= SNDRV_PCM_STREAM_LAST, return NULL);
return snd_pcm_stream_names[stream]; return snd_pcm_stream_names[stream];
...@@ -208,23 +208,20 @@ static const char *snd_pcm_stream_name(snd_pcm_stream_t stream) ...@@ -208,23 +208,20 @@ static const char *snd_pcm_stream_name(snd_pcm_stream_t stream)
static const char *snd_pcm_access_name(snd_pcm_access_t access) static const char *snd_pcm_access_name(snd_pcm_access_t access)
{ {
snd_assert(access <= SNDRV_PCM_ACCESS_LAST, return NULL);
return snd_pcm_access_names[access]; return snd_pcm_access_names[access];
} }
const char *snd_pcm_format_name(snd_pcm_format_t format) const char *snd_pcm_format_name(snd_pcm_format_t format)
{ {
snd_assert(format <= SNDRV_PCM_FORMAT_LAST, return NULL);
return snd_pcm_format_names[format]; return snd_pcm_format_names[format];
} }
static const char *snd_pcm_subformat_name(snd_pcm_subformat_t subformat) static const char *snd_pcm_subformat_name(snd_pcm_subformat_t subformat)
{ {
snd_assert(subformat <= SNDRV_PCM_SUBFORMAT_LAST, return NULL);
return snd_pcm_subformat_names[subformat]; return snd_pcm_subformat_names[subformat];
} }
static const char *snd_pcm_tstamp_mode_name(snd_pcm_tstamp_t mode) static const char *snd_pcm_tstamp_mode_name(int mode)
{ {
snd_assert(mode <= SNDRV_PCM_TSTAMP_LAST, return NULL); snd_assert(mode <= SNDRV_PCM_TSTAMP_LAST, return NULL);
return snd_pcm_tstamp_mode_names[mode]; return snd_pcm_tstamp_mode_names[mode];
...@@ -232,7 +229,6 @@ static const char *snd_pcm_tstamp_mode_name(snd_pcm_tstamp_t mode) ...@@ -232,7 +229,6 @@ static const char *snd_pcm_tstamp_mode_name(snd_pcm_tstamp_t mode)
static const char *snd_pcm_state_name(snd_pcm_state_t state) static const char *snd_pcm_state_name(snd_pcm_state_t state)
{ {
snd_assert(state <= SNDRV_PCM_STATE_LAST, return NULL);
return snd_pcm_state_names[state]; return snd_pcm_state_names[state];
} }
...@@ -268,9 +264,10 @@ static const char *snd_pcm_oss_format_name(int format) ...@@ -268,9 +264,10 @@ static const char *snd_pcm_oss_format_name(int format)
#endif #endif
#ifdef CONFIG_PROC_FS #ifdef CONFIG_PROC_FS
static void snd_pcm_proc_info_read(snd_pcm_substream_t *substream, snd_info_buffer_t *buffer) static void snd_pcm_proc_info_read(struct snd_pcm_substream *substream,
struct snd_info_buffer *buffer)
{ {
snd_pcm_info_t *info; struct snd_pcm_info *info;
int err; int err;
if (! substream) if (! substream)
...@@ -302,20 +299,25 @@ static void snd_pcm_proc_info_read(snd_pcm_substream_t *substream, snd_info_buff ...@@ -302,20 +299,25 @@ static void snd_pcm_proc_info_read(snd_pcm_substream_t *substream, snd_info_buff
kfree(info); kfree(info);
} }
static void snd_pcm_stream_proc_info_read(snd_info_entry_t *entry, snd_info_buffer_t *buffer) static void snd_pcm_stream_proc_info_read(struct snd_info_entry *entry,
struct snd_info_buffer *buffer)
{ {
snd_pcm_proc_info_read(((snd_pcm_str_t *)entry->private_data)->substream, buffer); snd_pcm_proc_info_read(((struct snd_pcm_str *)entry->private_data)->substream,
buffer);
} }
static void snd_pcm_substream_proc_info_read(snd_info_entry_t *entry, snd_info_buffer_t *buffer) static void snd_pcm_substream_proc_info_read(struct snd_info_entry *entry,
struct snd_info_buffer *buffer)
{ {
snd_pcm_proc_info_read((snd_pcm_substream_t *)entry->private_data, buffer); snd_pcm_proc_info_read((struct snd_pcm_substream *)entry->private_data,
buffer);
} }
static void snd_pcm_substream_proc_hw_params_read(snd_info_entry_t *entry, snd_info_buffer_t *buffer) static void snd_pcm_substream_proc_hw_params_read(struct snd_info_entry *entry,
struct snd_info_buffer *buffer)
{ {
snd_pcm_substream_t *substream = (snd_pcm_substream_t *)entry->private_data; struct snd_pcm_substream *substream = entry->private_data;
snd_pcm_runtime_t *runtime = substream->runtime; struct snd_pcm_runtime *runtime = substream->runtime;
if (!runtime) { if (!runtime) {
snd_iprintf(buffer, "closed\n"); snd_iprintf(buffer, "closed\n");
return; return;
...@@ -347,10 +349,11 @@ static void snd_pcm_substream_proc_hw_params_read(snd_info_entry_t *entry, snd_i ...@@ -347,10 +349,11 @@ static void snd_pcm_substream_proc_hw_params_read(snd_info_entry_t *entry, snd_i
snd_pcm_stream_unlock_irq(substream); snd_pcm_stream_unlock_irq(substream);
} }
static void snd_pcm_substream_proc_sw_params_read(snd_info_entry_t *entry, snd_info_buffer_t *buffer) static void snd_pcm_substream_proc_sw_params_read(struct snd_info_entry *entry,
struct snd_info_buffer *buffer)
{ {
snd_pcm_substream_t *substream = (snd_pcm_substream_t *)entry->private_data; struct snd_pcm_substream *substream = entry->private_data;
snd_pcm_runtime_t *runtime = substream->runtime; struct snd_pcm_runtime *runtime = substream->runtime;
if (!runtime) { if (!runtime) {
snd_iprintf(buffer, "closed\n"); snd_iprintf(buffer, "closed\n");
return; return;
...@@ -374,11 +377,12 @@ static void snd_pcm_substream_proc_sw_params_read(snd_info_entry_t *entry, snd_i ...@@ -374,11 +377,12 @@ static void snd_pcm_substream_proc_sw_params_read(snd_info_entry_t *entry, snd_i
snd_pcm_stream_unlock_irq(substream); snd_pcm_stream_unlock_irq(substream);
} }
static void snd_pcm_substream_proc_status_read(snd_info_entry_t *entry, snd_info_buffer_t *buffer) static void snd_pcm_substream_proc_status_read(struct snd_info_entry *entry,
struct snd_info_buffer *buffer)
{ {
snd_pcm_substream_t *substream = (snd_pcm_substream_t *)entry->private_data; struct snd_pcm_substream *substream = entry->private_data;
snd_pcm_runtime_t *runtime = substream->runtime; struct snd_pcm_runtime *runtime = substream->runtime;
snd_pcm_status_t status; struct snd_pcm_status status;
int err; int err;
if (!runtime) { if (!runtime) {
snd_iprintf(buffer, "closed\n"); snd_iprintf(buffer, "closed\n");
...@@ -405,25 +409,27 @@ static void snd_pcm_substream_proc_status_read(snd_info_entry_t *entry, snd_info ...@@ -405,25 +409,27 @@ static void snd_pcm_substream_proc_status_read(snd_info_entry_t *entry, snd_info
#endif #endif
#ifdef CONFIG_SND_DEBUG #ifdef CONFIG_SND_DEBUG
static void snd_pcm_xrun_debug_read(snd_info_entry_t *entry, snd_info_buffer_t *buffer) static void snd_pcm_xrun_debug_read(struct snd_info_entry *entry,
struct snd_info_buffer *buffer)
{ {
snd_pcm_str_t *pstr = (snd_pcm_str_t *)entry->private_data; struct snd_pcm_str *pstr = entry->private_data;
snd_iprintf(buffer, "%d\n", pstr->xrun_debug); snd_iprintf(buffer, "%d\n", pstr->xrun_debug);
} }
static void snd_pcm_xrun_debug_write(snd_info_entry_t *entry, snd_info_buffer_t *buffer) static void snd_pcm_xrun_debug_write(struct snd_info_entry *entry,
struct snd_info_buffer *buffer)
{ {
snd_pcm_str_t *pstr = (snd_pcm_str_t *)entry->private_data; struct snd_pcm_str *pstr = entry->private_data;
char line[64]; char line[64];
if (!snd_info_get_line(buffer, line, sizeof(line))) if (!snd_info_get_line(buffer, line, sizeof(line)))
pstr->xrun_debug = simple_strtoul(line, NULL, 10); pstr->xrun_debug = simple_strtoul(line, NULL, 10);
} }
#endif #endif
static int snd_pcm_stream_proc_init(snd_pcm_str_t *pstr) static int snd_pcm_stream_proc_init(struct snd_pcm_str *pstr)
{ {
snd_pcm_t *pcm = pstr->pcm; struct snd_pcm *pcm = pstr->pcm;
snd_info_entry_t *entry; struct snd_info_entry *entry;
char name[16]; char name[16];
sprintf(name, "pcm%i%c", pcm->device, sprintf(name, "pcm%i%c", pcm->device,
...@@ -447,7 +453,8 @@ static int snd_pcm_stream_proc_init(snd_pcm_str_t *pstr) ...@@ -447,7 +453,8 @@ static int snd_pcm_stream_proc_init(snd_pcm_str_t *pstr)
pstr->proc_info_entry = entry; pstr->proc_info_entry = entry;
#ifdef CONFIG_SND_DEBUG #ifdef CONFIG_SND_DEBUG
if ((entry = snd_info_create_card_entry(pcm->card, "xrun_debug", pstr->proc_root)) != NULL) { if ((entry = snd_info_create_card_entry(pcm->card, "xrun_debug",
pstr->proc_root)) != NULL) {
entry->c.text.read_size = 64; entry->c.text.read_size = 64;
entry->c.text.read = snd_pcm_xrun_debug_read; entry->c.text.read = snd_pcm_xrun_debug_read;
entry->c.text.write_size = 64; entry->c.text.write_size = 64;
...@@ -464,7 +471,7 @@ static int snd_pcm_stream_proc_init(snd_pcm_str_t *pstr) ...@@ -464,7 +471,7 @@ static int snd_pcm_stream_proc_init(snd_pcm_str_t *pstr)
return 0; return 0;
} }
static int snd_pcm_stream_proc_done(snd_pcm_str_t *pstr) static int snd_pcm_stream_proc_done(struct snd_pcm_str *pstr)
{ {
#ifdef CONFIG_SND_DEBUG #ifdef CONFIG_SND_DEBUG
if (pstr->proc_xrun_debug_entry) { if (pstr->proc_xrun_debug_entry) {
...@@ -483,10 +490,10 @@ static int snd_pcm_stream_proc_done(snd_pcm_str_t *pstr) ...@@ -483,10 +490,10 @@ static int snd_pcm_stream_proc_done(snd_pcm_str_t *pstr)
return 0; return 0;
} }
static int snd_pcm_substream_proc_init(snd_pcm_substream_t *substream) static int snd_pcm_substream_proc_init(struct snd_pcm_substream *substream)
{ {
snd_info_entry_t *entry; struct snd_info_entry *entry;
snd_card_t *card; struct snd_card *card;
char name[16]; char name[16];
card = substream->pcm->card; card = substream->pcm->card;
...@@ -540,7 +547,7 @@ static int snd_pcm_substream_proc_init(snd_pcm_substream_t *substream) ...@@ -540,7 +547,7 @@ static int snd_pcm_substream_proc_init(snd_pcm_substream_t *substream)
return 0; return 0;
} }
static int snd_pcm_substream_proc_done(snd_pcm_substream_t *substream) static int snd_pcm_substream_proc_done(struct snd_pcm_substream *substream)
{ {
if (substream->proc_info_entry) { if (substream->proc_info_entry) {
snd_info_unregister(substream->proc_info_entry); snd_info_unregister(substream->proc_info_entry);
...@@ -578,11 +585,11 @@ static int snd_pcm_substream_proc_done(snd_pcm_substream_t *substream) ...@@ -578,11 +585,11 @@ static int snd_pcm_substream_proc_done(snd_pcm_substream_t *substream)
* *
* Returns zero if successful, or a negative error code on failure. * Returns zero if successful, or a negative error code on failure.
*/ */
int snd_pcm_new_stream(snd_pcm_t *pcm, int stream, int substream_count) int snd_pcm_new_stream(struct snd_pcm *pcm, int stream, int substream_count)
{ {
int idx, err; int idx, err;
snd_pcm_str_t *pstr = &pcm->streams[stream]; struct snd_pcm_str *pstr = &pcm->streams[stream];
snd_pcm_substream_t *substream, *prev; struct snd_pcm_substream *substream, *prev;
#if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE) #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
init_MUTEX(&pstr->oss.setup_mutex); init_MUTEX(&pstr->oss.setup_mutex);
...@@ -642,13 +649,13 @@ int snd_pcm_new_stream(snd_pcm_t *pcm, int stream, int substream_count) ...@@ -642,13 +649,13 @@ int snd_pcm_new_stream(snd_pcm_t *pcm, int stream, int substream_count)
* *
* Returns zero if successful, or a negative error code on failure. * Returns zero if successful, or a negative error code on failure.
*/ */
int snd_pcm_new(snd_card_t * card, char *id, int device, int snd_pcm_new(struct snd_card *card, char *id, int device,
int playback_count, int capture_count, int playback_count, int capture_count,
snd_pcm_t ** rpcm) struct snd_pcm ** rpcm)
{ {
snd_pcm_t *pcm; struct snd_pcm *pcm;
int err; int err;
static snd_device_ops_t ops = { static struct snd_device_ops ops = {
.dev_free = snd_pcm_dev_free, .dev_free = snd_pcm_dev_free,
.dev_register = snd_pcm_dev_register, .dev_register = snd_pcm_dev_register,
.dev_disconnect = snd_pcm_dev_disconnect, .dev_disconnect = snd_pcm_dev_disconnect,
...@@ -684,11 +691,11 @@ int snd_pcm_new(snd_card_t * card, char *id, int device, ...@@ -684,11 +691,11 @@ int snd_pcm_new(snd_card_t * card, char *id, int device,
return 0; return 0;
} }
static void snd_pcm_free_stream(snd_pcm_str_t * pstr) static void snd_pcm_free_stream(struct snd_pcm_str * pstr)
{ {
snd_pcm_substream_t *substream, *substream_next; struct snd_pcm_substream *substream, *substream_next;
#if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE) #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
snd_pcm_oss_setup_t *setup, *setupn; struct snd_pcm_oss_setup *setup, *setupn;
#endif #endif
substream = pstr->substream; substream = pstr->substream;
while (substream) { while (substream) {
...@@ -707,7 +714,7 @@ static void snd_pcm_free_stream(snd_pcm_str_t * pstr) ...@@ -707,7 +714,7 @@ static void snd_pcm_free_stream(snd_pcm_str_t * pstr)
#endif #endif
} }
static int snd_pcm_free(snd_pcm_t *pcm) static int snd_pcm_free(struct snd_pcm *pcm)
{ {
snd_assert(pcm != NULL, return -ENXIO); snd_assert(pcm != NULL, return -ENXIO);
if (pcm->private_free) if (pcm->private_free)
...@@ -719,26 +726,26 @@ static int snd_pcm_free(snd_pcm_t *pcm) ...@@ -719,26 +726,26 @@ static int snd_pcm_free(snd_pcm_t *pcm)
return 0; return 0;
} }
static int snd_pcm_dev_free(snd_device_t *device) static int snd_pcm_dev_free(struct snd_device *device)
{ {
snd_pcm_t *pcm = device->device_data; struct snd_pcm *pcm = device->device_data;
return snd_pcm_free(pcm); return snd_pcm_free(pcm);
} }
static void snd_pcm_tick_timer_func(unsigned long data) static void snd_pcm_tick_timer_func(unsigned long data)
{ {
snd_pcm_substream_t *substream = (snd_pcm_substream_t*) data; struct snd_pcm_substream *substream = (struct snd_pcm_substream *) data;
snd_pcm_tick_elapsed(substream); snd_pcm_tick_elapsed(substream);
} }
int snd_pcm_open_substream(snd_pcm_t *pcm, int stream, int snd_pcm_open_substream(struct snd_pcm *pcm, int stream,
snd_pcm_substream_t **rsubstream) struct snd_pcm_substream **rsubstream)
{ {
snd_pcm_str_t * pstr; struct snd_pcm_str * pstr;
snd_pcm_substream_t * substream; struct snd_pcm_substream *substream;
snd_pcm_runtime_t * runtime; struct snd_pcm_runtime *runtime;
snd_ctl_file_t *kctl; struct snd_ctl_file *kctl;
snd_card_t *card; struct snd_card *card;
struct list_head *list; struct list_head *list;
int prefer_subdevice = -1; int prefer_subdevice = -1;
size_t size; size_t size;
...@@ -800,7 +807,7 @@ int snd_pcm_open_substream(snd_pcm_t *pcm, int stream, ...@@ -800,7 +807,7 @@ int snd_pcm_open_substream(snd_pcm_t *pcm, int stream,
if (runtime == NULL) if (runtime == NULL)
return -ENOMEM; return -ENOMEM;
size = PAGE_ALIGN(sizeof(snd_pcm_mmap_status_t)); size = PAGE_ALIGN(sizeof(struct snd_pcm_mmap_status));
runtime->status = snd_malloc_pages(size, GFP_KERNEL); runtime->status = snd_malloc_pages(size, GFP_KERNEL);
if (runtime->status == NULL) { if (runtime->status == NULL) {
kfree(runtime); kfree(runtime);
...@@ -808,10 +815,11 @@ int snd_pcm_open_substream(snd_pcm_t *pcm, int stream, ...@@ -808,10 +815,11 @@ int snd_pcm_open_substream(snd_pcm_t *pcm, int stream,
} }
memset((void*)runtime->status, 0, size); memset((void*)runtime->status, 0, size);
size = PAGE_ALIGN(sizeof(snd_pcm_mmap_control_t)); size = PAGE_ALIGN(sizeof(struct snd_pcm_mmap_control));
runtime->control = snd_malloc_pages(size, GFP_KERNEL); runtime->control = snd_malloc_pages(size, GFP_KERNEL);
if (runtime->control == NULL) { if (runtime->control == NULL) {
snd_free_pages((void*)runtime->status, PAGE_ALIGN(sizeof(snd_pcm_mmap_status_t))); snd_free_pages((void*)runtime->status,
PAGE_ALIGN(sizeof(struct snd_pcm_mmap_status)));
kfree(runtime); kfree(runtime);
return -ENOMEM; return -ENOMEM;
} }
...@@ -832,30 +840,32 @@ int snd_pcm_open_substream(snd_pcm_t *pcm, int stream, ...@@ -832,30 +840,32 @@ int snd_pcm_open_substream(snd_pcm_t *pcm, int stream,
return 0; return 0;
} }
void snd_pcm_release_substream(snd_pcm_substream_t *substream) void snd_pcm_release_substream(struct snd_pcm_substream *substream)
{ {
snd_pcm_runtime_t * runtime; struct snd_pcm_runtime *runtime;
substream->file = NULL; substream->file = NULL;
runtime = substream->runtime; runtime = substream->runtime;
snd_assert(runtime != NULL, return); snd_assert(runtime != NULL, return);
if (runtime->private_free != NULL) if (runtime->private_free != NULL)
runtime->private_free(runtime); runtime->private_free(runtime);
snd_free_pages((void*)runtime->status, PAGE_ALIGN(sizeof(snd_pcm_mmap_status_t))); snd_free_pages((void*)runtime->status,
snd_free_pages((void*)runtime->control, PAGE_ALIGN(sizeof(snd_pcm_mmap_control_t))); PAGE_ALIGN(sizeof(struct snd_pcm_mmap_status)));
snd_free_pages((void*)runtime->control,
PAGE_ALIGN(sizeof(struct snd_pcm_mmap_control)));
kfree(runtime->hw_constraints.rules); kfree(runtime->hw_constraints.rules);
kfree(runtime); kfree(runtime);
substream->runtime = NULL; substream->runtime = NULL;
substream->pstr->substream_opened--; substream->pstr->substream_opened--;
} }
static int snd_pcm_dev_register(snd_device_t *device) static int snd_pcm_dev_register(struct snd_device *device)
{ {
int idx, cidx, err; int idx, cidx, err;
unsigned short minor; unsigned short minor;
snd_pcm_substream_t *substream; struct snd_pcm_substream *substream;
struct list_head *list; struct list_head *list;
char str[16]; char str[16];
snd_pcm_t *pcm = device->device_data; struct snd_pcm *pcm = device->device_data;
snd_assert(pcm != NULL && device != NULL, return -ENXIO); snd_assert(pcm != NULL && device != NULL, return -ENXIO);
down(&register_mutex); down(&register_mutex);
...@@ -890,19 +900,19 @@ static int snd_pcm_dev_register(snd_device_t *device) ...@@ -890,19 +900,19 @@ static int snd_pcm_dev_register(snd_device_t *device)
snd_pcm_timer_init(substream); snd_pcm_timer_init(substream);
} }
list_for_each(list, &snd_pcm_notify_list) { list_for_each(list, &snd_pcm_notify_list) {
snd_pcm_notify_t *notify; struct snd_pcm_notify *notify;
notify = list_entry(list, snd_pcm_notify_t, list); notify = list_entry(list, struct snd_pcm_notify, list);
notify->n_register(pcm); notify->n_register(pcm);
} }
up(&register_mutex); up(&register_mutex);
return 0; return 0;
} }
static int snd_pcm_dev_disconnect(snd_device_t *device) static int snd_pcm_dev_disconnect(struct snd_device *device)
{ {
snd_pcm_t *pcm = device->device_data; struct snd_pcm *pcm = device->device_data;
struct list_head *list; struct list_head *list;
snd_pcm_substream_t *substream; struct snd_pcm_substream *substream;
int idx, cidx; int idx, cidx;
down(&register_mutex); down(&register_mutex);
...@@ -913,20 +923,20 @@ static int snd_pcm_dev_disconnect(snd_device_t *device) ...@@ -913,20 +923,20 @@ static int snd_pcm_dev_disconnect(snd_device_t *device)
if (substream->runtime) if (substream->runtime)
substream->runtime->status->state = SNDRV_PCM_STATE_DISCONNECTED; substream->runtime->status->state = SNDRV_PCM_STATE_DISCONNECTED;
list_for_each(list, &snd_pcm_notify_list) { list_for_each(list, &snd_pcm_notify_list) {
snd_pcm_notify_t *notify; struct snd_pcm_notify *notify;
notify = list_entry(list, snd_pcm_notify_t, list); notify = list_entry(list, struct snd_pcm_notify, list);
notify->n_disconnect(pcm); notify->n_disconnect(pcm);
} }
up(&register_mutex); up(&register_mutex);
return 0; return 0;
} }
static int snd_pcm_dev_unregister(snd_device_t *device) static int snd_pcm_dev_unregister(struct snd_device *device)
{ {
int idx, cidx, devtype; int idx, cidx, devtype;
snd_pcm_substream_t *substream; struct snd_pcm_substream *substream;
struct list_head *list; struct list_head *list;
snd_pcm_t *pcm = device->device_data; struct snd_pcm *pcm = device->device_data;
snd_assert(pcm != NULL, return -ENXIO); snd_assert(pcm != NULL, return -ENXIO);
down(&register_mutex); down(&register_mutex);
...@@ -947,15 +957,15 @@ static int snd_pcm_dev_unregister(snd_device_t *device) ...@@ -947,15 +957,15 @@ static int snd_pcm_dev_unregister(snd_device_t *device)
snd_pcm_timer_done(substream); snd_pcm_timer_done(substream);
} }
list_for_each(list, &snd_pcm_notify_list) { list_for_each(list, &snd_pcm_notify_list) {
snd_pcm_notify_t *notify; struct snd_pcm_notify *notify;
notify = list_entry(list, snd_pcm_notify_t, list); notify = list_entry(list, struct snd_pcm_notify, list);
notify->n_unregister(pcm); notify->n_unregister(pcm);
} }
up(&register_mutex); up(&register_mutex);
return snd_pcm_free(pcm); return snd_pcm_free(pcm);
} }
int snd_pcm_notify(snd_pcm_notify_t *notify, int nfree) int snd_pcm_notify(struct snd_pcm_notify *notify, int nfree)
{ {
int idx; int idx;
...@@ -984,10 +994,11 @@ int snd_pcm_notify(snd_pcm_notify_t *notify, int nfree) ...@@ -984,10 +994,11 @@ int snd_pcm_notify(snd_pcm_notify_t *notify, int nfree)
* Info interface * Info interface
*/ */
static void snd_pcm_proc_read(snd_info_entry_t *entry, snd_info_buffer_t * buffer) static void snd_pcm_proc_read(struct snd_info_entry *entry,
struct snd_info_buffer *buffer)
{ {
int idx; int idx;
snd_pcm_t *pcm; struct snd_pcm *pcm;
down(&register_mutex); down(&register_mutex);
for (idx = 0; idx < SNDRV_CARDS * SNDRV_PCM_DEVICES; idx++) { for (idx = 0; idx < SNDRV_CARDS * SNDRV_PCM_DEVICES; idx++) {
...@@ -997,9 +1008,11 @@ static void snd_pcm_proc_read(snd_info_entry_t *entry, snd_info_buffer_t * buffe ...@@ -997,9 +1008,11 @@ static void snd_pcm_proc_read(snd_info_entry_t *entry, snd_info_buffer_t * buffe
snd_iprintf(buffer, "%02i-%02i: %s : %s", idx / SNDRV_PCM_DEVICES, snd_iprintf(buffer, "%02i-%02i: %s : %s", idx / SNDRV_PCM_DEVICES,
idx % SNDRV_PCM_DEVICES, pcm->id, pcm->name); idx % SNDRV_PCM_DEVICES, pcm->id, pcm->name);
if (pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream) if (pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream)
snd_iprintf(buffer, " : playback %i", pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream_count); snd_iprintf(buffer, " : playback %i",
pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream_count);
if (pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream) if (pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream)
snd_iprintf(buffer, " : capture %i", pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream_count); snd_iprintf(buffer, " : capture %i",
pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream_count);
snd_iprintf(buffer, "\n"); snd_iprintf(buffer, "\n");
} }
up(&register_mutex); up(&register_mutex);
...@@ -1009,16 +1022,17 @@ static void snd_pcm_proc_read(snd_info_entry_t *entry, snd_info_buffer_t * buffe ...@@ -1009,16 +1022,17 @@ static void snd_pcm_proc_read(snd_info_entry_t *entry, snd_info_buffer_t * buffe
* ENTRY functions * ENTRY functions
*/ */
static snd_info_entry_t *snd_pcm_proc_entry = NULL; static struct snd_info_entry *snd_pcm_proc_entry = NULL;
static int __init alsa_pcm_init(void) static int __init alsa_pcm_init(void)
{ {
snd_info_entry_t *entry; struct snd_info_entry *entry;
snd_ctl_register_ioctl(snd_pcm_control_ioctl); snd_ctl_register_ioctl(snd_pcm_control_ioctl);
snd_ctl_register_ioctl_compat(snd_pcm_control_ioctl); snd_ctl_register_ioctl_compat(snd_pcm_control_ioctl);
if ((entry = snd_info_create_module_entry(THIS_MODULE, "pcm", NULL)) != NULL) { if ((entry = snd_info_create_module_entry(THIS_MODULE, "pcm", NULL)) != NULL) {
snd_info_set_text_ops(entry, NULL, SNDRV_CARDS * SNDRV_PCM_DEVICES * 128, snd_pcm_proc_read); snd_info_set_text_ops(entry, NULL, SNDRV_CARDS * SNDRV_PCM_DEVICES * 128,
snd_pcm_proc_read);
if (snd_info_register(entry) < 0) { if (snd_info_register(entry) < 0) {
snd_info_free_entry(entry); snd_info_free_entry(entry);
entry = NULL; entry = NULL;
......
sound/core/pcm_compat.c
浏览文件 @ 877211f5
...@@ -22,7 +22,7 @@ ...@@ -22,7 +22,7 @@
#include <linux/compat.h> #include <linux/compat.h>
static int snd_pcm_ioctl_delay_compat(snd_pcm_substream_t *substream, static int snd_pcm_ioctl_delay_compat(struct snd_pcm_substream *substream,
s32 __user *src) s32 __user *src)
{ {
snd_pcm_sframes_t delay; snd_pcm_sframes_t delay;
...@@ -39,7 +39,7 @@ static int snd_pcm_ioctl_delay_compat(snd_pcm_substream_t *substream, ...@@ -39,7 +39,7 @@ static int snd_pcm_ioctl_delay_compat(snd_pcm_substream_t *substream,
return err; return err;
} }
static int snd_pcm_ioctl_rewind_compat(snd_pcm_substream_t *substream, static int snd_pcm_ioctl_rewind_compat(struct snd_pcm_substream *substream,
u32 __user *src) u32 __user *src)
{ {
snd_pcm_uframes_t frames; snd_pcm_uframes_t frames;
...@@ -56,7 +56,7 @@ static int snd_pcm_ioctl_rewind_compat(snd_pcm_substream_t *substream, ...@@ -56,7 +56,7 @@ static int snd_pcm_ioctl_rewind_compat(snd_pcm_substream_t *substream,
return err < 0 ? err : 0; return err < 0 ? err : 0;
} }
static int snd_pcm_ioctl_forward_compat(snd_pcm_substream_t *substream, static int snd_pcm_ioctl_forward_compat(struct snd_pcm_substream *substream,
u32 __user *src) u32 __user *src)
{ {
snd_pcm_uframes_t frames; snd_pcm_uframes_t frames;
...@@ -73,12 +73,12 @@ static int snd_pcm_ioctl_forward_compat(snd_pcm_substream_t *substream, ...@@ -73,12 +73,12 @@ static int snd_pcm_ioctl_forward_compat(snd_pcm_substream_t *substream,
return err < 0 ? err : 0; return err < 0 ? err : 0;
} }
struct sndrv_pcm_hw_params32 { struct snd_pcm_hw_params32 {
u32 flags; u32 flags;
struct sndrv_mask masks[SNDRV_PCM_HW_PARAM_LAST_MASK - SNDRV_PCM_HW_PARAM_FIRST_MASK + 1]; /* this must be identical */ struct snd_mask masks[SNDRV_PCM_HW_PARAM_LAST_MASK - SNDRV_PCM_HW_PARAM_FIRST_MASK + 1]; /* this must be identical */
struct sndrv_mask mres[5]; /* reserved masks */ struct snd_mask mres[5]; /* reserved masks */
struct sndrv_interval intervals[SNDRV_PCM_HW_PARAM_LAST_INTERVAL - SNDRV_PCM_HW_PARAM_FIRST_INTERVAL + 1]; struct snd_interval intervals[SNDRV_PCM_HW_PARAM_LAST_INTERVAL - SNDRV_PCM_HW_PARAM_FIRST_INTERVAL + 1];
struct sndrv_interval ires[9]; /* reserved intervals */ struct snd_interval ires[9]; /* reserved intervals */
u32 rmask; u32 rmask;
u32 cmask; u32 cmask;
u32 info; u32 info;
...@@ -89,7 +89,7 @@ struct sndrv_pcm_hw_params32 { ...@@ -89,7 +89,7 @@ struct sndrv_pcm_hw_params32 {
unsigned char reserved[64]; unsigned char reserved[64];
}; };
struct sndrv_pcm_sw_params32 { struct snd_pcm_sw_params32 {
s32 tstamp_mode; s32 tstamp_mode;
u32 period_step; u32 period_step;
u32 sleep_min; u32 sleep_min;
...@@ -104,7 +104,7 @@ struct sndrv_pcm_sw_params32 { ...@@ -104,7 +104,7 @@ struct sndrv_pcm_sw_params32 {
}; };
/* recalcuate the boundary within 32bit */ /* recalcuate the boundary within 32bit */
static snd_pcm_uframes_t recalculate_boundary(snd_pcm_runtime_t *runtime) static snd_pcm_uframes_t recalculate_boundary(struct snd_pcm_runtime *runtime)
{ {
snd_pcm_uframes_t boundary; snd_pcm_uframes_t boundary;
...@@ -116,10 +116,10 @@ static snd_pcm_uframes_t recalculate_boundary(snd_pcm_runtime_t *runtime) ...@@ -116,10 +116,10 @@ static snd_pcm_uframes_t recalculate_boundary(snd_pcm_runtime_t *runtime)
return boundary; return boundary;
} }
static int snd_pcm_ioctl_sw_params_compat(snd_pcm_substream_t *substream, static int snd_pcm_ioctl_sw_params_compat(struct snd_pcm_substream *substream,
struct sndrv_pcm_sw_params32 __user *src) struct snd_pcm_sw_params32 __user *src)
{ {
snd_pcm_sw_params_t params; struct snd_pcm_sw_params params;
snd_pcm_uframes_t boundary; snd_pcm_uframes_t boundary;
int err; int err;
...@@ -149,17 +149,17 @@ static int snd_pcm_ioctl_sw_params_compat(snd_pcm_substream_t *substream, ...@@ -149,17 +149,17 @@ static int snd_pcm_ioctl_sw_params_compat(snd_pcm_substream_t *substream,
return err; return err;
} }
struct sndrv_pcm_channel_info32 { struct snd_pcm_channel_info32 {
u32 channel; u32 channel;
u32 offset; u32 offset;
u32 first; u32 first;
u32 step; u32 step;
}; };
static int snd_pcm_ioctl_channel_info_compat(snd_pcm_substream_t *substream, static int snd_pcm_ioctl_channel_info_compat(struct snd_pcm_substream *substream,
struct sndrv_pcm_channel_info32 __user *src) struct snd_pcm_channel_info32 __user *src)
{ {
snd_pcm_channel_info_t info; struct snd_pcm_channel_info info;
int err; int err;
if (get_user(info.channel, &src->channel) || if (get_user(info.channel, &src->channel) ||
...@@ -178,7 +178,7 @@ static int snd_pcm_ioctl_channel_info_compat(snd_pcm_substream_t *substream, ...@@ -178,7 +178,7 @@ static int snd_pcm_ioctl_channel_info_compat(snd_pcm_substream_t *substream,
return err; return err;
} }
struct sndrv_pcm_status32 { struct snd_pcm_status32 {
s32 state; s32 state;
struct compat_timespec trigger_tstamp; struct compat_timespec trigger_tstamp;
struct compat_timespec tstamp; struct compat_timespec tstamp;
...@@ -193,10 +193,10 @@ struct sndrv_pcm_status32 { ...@@ -193,10 +193,10 @@ struct sndrv_pcm_status32 {
} __attribute__((packed)); } __attribute__((packed));
static int snd_pcm_status_user_compat(snd_pcm_substream_t *substream, static int snd_pcm_status_user_compat(struct snd_pcm_substream *substream,
struct sndrv_pcm_status32 __user *src) struct snd_pcm_status32 __user *src)
{ {
snd_pcm_status_t status; struct snd_pcm_status status;
int err; int err;
err = snd_pcm_status(substream, &status); err = snd_pcm_status(substream, &status);
...@@ -221,12 +221,12 @@ static int snd_pcm_status_user_compat(snd_pcm_substream_t *substream, ...@@ -221,12 +221,12 @@ static int snd_pcm_status_user_compat(snd_pcm_substream_t *substream,
} }
/* both for HW_PARAMS and HW_REFINE */ /* both for HW_PARAMS and HW_REFINE */
static int snd_pcm_ioctl_hw_params_compat(snd_pcm_substream_t *substream, static int snd_pcm_ioctl_hw_params_compat(struct snd_pcm_substream *substream,
int refine, int refine,
struct sndrv_pcm_hw_params32 __user *data32) struct snd_pcm_hw_params32 __user *data32)
{ {
struct sndrv_pcm_hw_params *data; struct snd_pcm_hw_params *data;
snd_pcm_runtime_t *runtime; struct snd_pcm_runtime *runtime;
int err; int err;
if (! (runtime = substream->runtime)) if (! (runtime = substream->runtime))
...@@ -265,14 +265,14 @@ static int snd_pcm_ioctl_hw_params_compat(snd_pcm_substream_t *substream, ...@@ -265,14 +265,14 @@ static int snd_pcm_ioctl_hw_params_compat(snd_pcm_substream_t *substream,
/* /*
*/ */
struct sndrv_xferi32 { struct snd_xferi32 {
s32 result; s32 result;
u32 buf; u32 buf;
u32 frames; u32 frames;
}; };
static int snd_pcm_ioctl_xferi_compat(snd_pcm_substream_t *substream, static int snd_pcm_ioctl_xferi_compat(struct snd_pcm_substream *substream,
int dir, struct sndrv_xferi32 __user *data32) int dir, struct snd_xferi32 __user *data32)
{ {
compat_caddr_t buf; compat_caddr_t buf;
u32 frames; u32 frames;
...@@ -303,7 +303,7 @@ static int snd_pcm_ioctl_xferi_compat(snd_pcm_substream_t *substream, ...@@ -303,7 +303,7 @@ static int snd_pcm_ioctl_xferi_compat(snd_pcm_substream_t *substream,
/* snd_xfern needs remapping of bufs */ /* snd_xfern needs remapping of bufs */
struct sndrv_xfern32 { struct snd_xfern32 {
s32 result; s32 result;
u32 bufs; /* this is void **; */ u32 bufs; /* this is void **; */
u32 frames; u32 frames;
...@@ -315,8 +315,8 @@ struct sndrv_xfern32 { ...@@ -315,8 +315,8 @@ struct sndrv_xfern32 {
* handler there expands again the same 128 pointers on stack, so it is better * handler there expands again the same 128 pointers on stack, so it is better
* to handle the function (calling pcm_readv/writev) directly in this handler. * to handle the function (calling pcm_readv/writev) directly in this handler.
*/ */
static int snd_pcm_ioctl_xfern_compat(snd_pcm_substream_t *substream, static int snd_pcm_ioctl_xfern_compat(struct snd_pcm_substream *substream,
int dir, struct sndrv_xfern32 __user *data32) int dir, struct snd_xfern32 __user *data32)
{ {
compat_caddr_t buf; compat_caddr_t buf;
compat_caddr_t __user *bufptr; compat_caddr_t __user *bufptr;
...@@ -360,7 +360,7 @@ static int snd_pcm_ioctl_xfern_compat(snd_pcm_substream_t *substream, ...@@ -360,7 +360,7 @@ static int snd_pcm_ioctl_xfern_compat(snd_pcm_substream_t *substream,
} }
struct sndrv_pcm_mmap_status32 { struct snd_pcm_mmap_status32 {
s32 state; s32 state;
s32 pad1; s32 pad1;
u32 hw_ptr; u32 hw_ptr;
...@@ -368,32 +368,32 @@ struct sndrv_pcm_mmap_status32 { ...@@ -368,32 +368,32 @@ struct sndrv_pcm_mmap_status32 {
s32 suspended_state; s32 suspended_state;
} __attribute__((packed)); } __attribute__((packed));
struct sndrv_pcm_mmap_control32 { struct snd_pcm_mmap_control32 {
u32 appl_ptr; u32 appl_ptr;
u32 avail_min; u32 avail_min;
}; };
struct sndrv_pcm_sync_ptr32 { struct snd_pcm_sync_ptr32 {
u32 flags; u32 flags;
union { union {
struct sndrv_pcm_mmap_status32 status; struct snd_pcm_mmap_status32 status;
unsigned char reserved[64]; unsigned char reserved[64];
} s; } s;
union { union {
struct sndrv_pcm_mmap_control32 control; struct snd_pcm_mmap_control32 control;
unsigned char reserved[64]; unsigned char reserved[64];
} c; } c;
} __attribute__((packed)); } __attribute__((packed));
static int snd_pcm_ioctl_sync_ptr_compat(snd_pcm_substream_t *substream, static int snd_pcm_ioctl_sync_ptr_compat(struct snd_pcm_substream *substream,
struct sndrv_pcm_sync_ptr32 __user *src) struct snd_pcm_sync_ptr32 __user *src)
{ {
snd_pcm_runtime_t *runtime = substream->runtime; struct snd_pcm_runtime *runtime = substream->runtime;
volatile struct sndrv_pcm_mmap_status *status; volatile struct snd_pcm_mmap_status *status;
volatile struct sndrv_pcm_mmap_control *control; volatile struct snd_pcm_mmap_control *control;
u32 sflags; u32 sflags;
struct sndrv_pcm_mmap_control scontrol; struct snd_pcm_mmap_control scontrol;
struct sndrv_pcm_mmap_status sstatus; struct snd_pcm_mmap_status sstatus;
snd_pcm_uframes_t boundary; snd_pcm_uframes_t boundary;
int err; int err;
...@@ -444,26 +444,26 @@ static int snd_pcm_ioctl_sync_ptr_compat(snd_pcm_substream_t *substream, ...@@ -444,26 +444,26 @@ static int snd_pcm_ioctl_sync_ptr_compat(snd_pcm_substream_t *substream,
/* /*
*/ */
enum { enum {
SNDRV_PCM_IOCTL_HW_REFINE32 = _IOWR('A', 0x10, struct sndrv_pcm_hw_params32), SNDRV_PCM_IOCTL_HW_REFINE32 = _IOWR('A', 0x10, struct snd_pcm_hw_params32),
SNDRV_PCM_IOCTL_HW_PARAMS32 = _IOWR('A', 0x11, struct sndrv_pcm_hw_params32), SNDRV_PCM_IOCTL_HW_PARAMS32 = _IOWR('A', 0x11, struct snd_pcm_hw_params32),
SNDRV_PCM_IOCTL_SW_PARAMS32 = _IOWR('A', 0x13, struct sndrv_pcm_sw_params32), SNDRV_PCM_IOCTL_SW_PARAMS32 = _IOWR('A', 0x13, struct snd_pcm_sw_params32),
SNDRV_PCM_IOCTL_STATUS32 = _IOR('A', 0x20, struct sndrv_pcm_status32), SNDRV_PCM_IOCTL_STATUS32 = _IOR('A', 0x20, struct snd_pcm_status32),
SNDRV_PCM_IOCTL_DELAY32 = _IOR('A', 0x21, s32), SNDRV_PCM_IOCTL_DELAY32 = _IOR('A', 0x21, s32),
SNDRV_PCM_IOCTL_CHANNEL_INFO32 = _IOR('A', 0x32, struct sndrv_pcm_channel_info32), SNDRV_PCM_IOCTL_CHANNEL_INFO32 = _IOR('A', 0x32, struct snd_pcm_channel_info32),
SNDRV_PCM_IOCTL_REWIND32 = _IOW('A', 0x46, u32), SNDRV_PCM_IOCTL_REWIND32 = _IOW('A', 0x46, u32),
SNDRV_PCM_IOCTL_FORWARD32 = _IOW('A', 0x49, u32), SNDRV_PCM_IOCTL_FORWARD32 = _IOW('A', 0x49, u32),
SNDRV_PCM_IOCTL_WRITEI_FRAMES32 = _IOW('A', 0x50, struct sndrv_xferi32), SNDRV_PCM_IOCTL_WRITEI_FRAMES32 = _IOW('A', 0x50, struct snd_xferi32),
SNDRV_PCM_IOCTL_READI_FRAMES32 = _IOR('A', 0x51, struct sndrv_xferi32), SNDRV_PCM_IOCTL_READI_FRAMES32 = _IOR('A', 0x51, struct snd_xferi32),
SNDRV_PCM_IOCTL_WRITEN_FRAMES32 = _IOW('A', 0x52, struct sndrv_xfern32), SNDRV_PCM_IOCTL_WRITEN_FRAMES32 = _IOW('A', 0x52, struct snd_xfern32),
SNDRV_PCM_IOCTL_READN_FRAMES32 = _IOR('A', 0x53, struct sndrv_xfern32), SNDRV_PCM_IOCTL_READN_FRAMES32 = _IOR('A', 0x53, struct snd_xfern32),
SNDRV_PCM_IOCTL_SYNC_PTR32 = _IOWR('A', 0x23, struct sndrv_pcm_sync_ptr32), SNDRV_PCM_IOCTL_SYNC_PTR32 = _IOWR('A', 0x23, struct snd_pcm_sync_ptr32),
}; };
static long snd_pcm_ioctl_compat(struct file *file, unsigned int cmd, unsigned long arg) static long snd_pcm_ioctl_compat(struct file *file, unsigned int cmd, unsigned long arg)
{ {
snd_pcm_file_t *pcm_file; struct snd_pcm_file *pcm_file;
snd_pcm_substream_t *substream; struct snd_pcm_substream *substream;
void __user *argp = compat_ptr(arg); void __user *argp = compat_ptr(arg);
pcm_file = file->private_data; pcm_file = file->private_data;
......
sound/core/pcm_lib.c
浏览文件 @ 877211f5
此差异已折叠。
sound/core/pcm_memory.c
浏览文件 @ 877211f5
...@@ -46,7 +46,7 @@ static const size_t snd_minimum_buffer = 16384; ...@@ -46,7 +46,7 @@ static const size_t snd_minimum_buffer = 16384;
* *
* the minimum size is snd_minimum_buffer. it should be power of 2. * the minimum size is snd_minimum_buffer. it should be power of 2.
*/ */
static int preallocate_pcm_pages(snd_pcm_substream_t *substream, size_t size) static int preallocate_pcm_pages(struct snd_pcm_substream *substream, size_t size)
{ {
struct snd_dma_buffer *dmab = &substream->dma_buffer; struct snd_dma_buffer *dmab = &substream->dma_buffer;
int err; int err;
...@@ -78,7 +78,7 @@ static int preallocate_pcm_pages(snd_pcm_substream_t *substream, size_t size) ...@@ -78,7 +78,7 @@ static int preallocate_pcm_pages(snd_pcm_substream_t *substream, size_t size)
/* /*
* release the preallocated buffer if not yet done. * release the preallocated buffer if not yet done.
*/ */
static void snd_pcm_lib_preallocate_dma_free(snd_pcm_substream_t *substream) static void snd_pcm_lib_preallocate_dma_free(struct snd_pcm_substream *substream)
{ {
if (substream->dma_buffer.area == NULL) if (substream->dma_buffer.area == NULL)
return; return;
...@@ -97,7 +97,7 @@ static void snd_pcm_lib_preallocate_dma_free(snd_pcm_substream_t *substream) ...@@ -97,7 +97,7 @@ static void snd_pcm_lib_preallocate_dma_free(snd_pcm_substream_t *substream)
* *
* Returns zero if successful, or a negative error code on failure. * Returns zero if successful, or a negative error code on failure.
*/ */
int snd_pcm_lib_preallocate_free(snd_pcm_substream_t *substream) int snd_pcm_lib_preallocate_free(struct snd_pcm_substream *substream)
{ {
snd_pcm_lib_preallocate_dma_free(substream); snd_pcm_lib_preallocate_dma_free(substream);
if (substream->proc_prealloc_entry) { if (substream->proc_prealloc_entry) {
...@@ -115,9 +115,9 @@ int snd_pcm_lib_preallocate_free(snd_pcm_substream_t *substream) ...@@ -115,9 +115,9 @@ int snd_pcm_lib_preallocate_free(snd_pcm_substream_t *substream)
* *
* Returns zero if successful, or a negative error code on failure. * Returns zero if successful, or a negative error code on failure.
*/ */
int snd_pcm_lib_preallocate_free_for_all(snd_pcm_t *pcm) int snd_pcm_lib_preallocate_free_for_all(struct snd_pcm *pcm)
{ {
snd_pcm_substream_t *substream; struct snd_pcm_substream *substream;
int stream; int stream;
for (stream = 0; stream < 2; stream++) for (stream = 0; stream < 2; stream++)
...@@ -131,10 +131,10 @@ int snd_pcm_lib_preallocate_free_for_all(snd_pcm_t *pcm) ...@@ -131,10 +131,10 @@ int snd_pcm_lib_preallocate_free_for_all(snd_pcm_t *pcm)
* *
* prints the current allocated size in kB. * prints the current allocated size in kB.
*/ */
static void snd_pcm_lib_preallocate_proc_read(snd_info_entry_t *entry, static void snd_pcm_lib_preallocate_proc_read(struct snd_info_entry *entry,
snd_info_buffer_t *buffer) struct snd_info_buffer *buffer)
{ {
snd_pcm_substream_t *substream = (snd_pcm_substream_t *)entry->private_data; struct snd_pcm_substream *substream = entry->private_data;
snd_iprintf(buffer, "%lu\n", (unsigned long) substream->dma_buffer.bytes / 1024); snd_iprintf(buffer, "%lu\n", (unsigned long) substream->dma_buffer.bytes / 1024);
} }
...@@ -143,10 +143,10 @@ static void snd_pcm_lib_preallocate_proc_read(snd_info_entry_t *entry, ...@@ -143,10 +143,10 @@ static void snd_pcm_lib_preallocate_proc_read(snd_info_entry_t *entry,
* *
* accepts the preallocation size in kB. * accepts the preallocation size in kB.
*/ */
static void snd_pcm_lib_preallocate_proc_write(snd_info_entry_t *entry, static void snd_pcm_lib_preallocate_proc_write(struct snd_info_entry *entry,
snd_info_buffer_t *buffer) struct snd_info_buffer *buffer)
{ {
snd_pcm_substream_t *substream = (snd_pcm_substream_t *)entry->private_data; struct snd_pcm_substream *substream = entry->private_data;
char line[64], str[64]; char line[64], str[64];
size_t size; size_t size;
struct snd_dma_buffer new_dmab; struct snd_dma_buffer new_dmab;
...@@ -188,10 +188,10 @@ static void snd_pcm_lib_preallocate_proc_write(snd_info_entry_t *entry, ...@@ -188,10 +188,10 @@ static void snd_pcm_lib_preallocate_proc_write(snd_info_entry_t *entry,
/* /*
* pre-allocate the buffer and create a proc file for the substream * pre-allocate the buffer and create a proc file for the substream
*/ */
static int snd_pcm_lib_preallocate_pages1(snd_pcm_substream_t *substream, static int snd_pcm_lib_preallocate_pages1(struct snd_pcm_substream *substream,
size_t size, size_t max) size_t size, size_t max)
{ {
snd_info_entry_t *entry; struct snd_info_entry *entry;
if (size > 0 && preallocate_dma && substream->number < maximum_substreams) if (size > 0 && preallocate_dma && substream->number < maximum_substreams)
preallocate_pcm_pages(substream, size); preallocate_pcm_pages(substream, size);
...@@ -233,7 +233,7 @@ static int snd_pcm_lib_preallocate_pages1(snd_pcm_substream_t *substream, ...@@ -233,7 +233,7 @@ static int snd_pcm_lib_preallocate_pages1(snd_pcm_substream_t *substream,
* *
* Returns zero if successful, or a negative error code on failure. * Returns zero if successful, or a negative error code on failure.
*/ */
int snd_pcm_lib_preallocate_pages(snd_pcm_substream_t *substream, int snd_pcm_lib_preallocate_pages(struct snd_pcm_substream *substream,
int type, struct device *data, int type, struct device *data,
size_t size, size_t max) size_t size, size_t max)
{ {
...@@ -255,11 +255,11 @@ int snd_pcm_lib_preallocate_pages(snd_pcm_substream_t *substream, ...@@ -255,11 +255,11 @@ int snd_pcm_lib_preallocate_pages(snd_pcm_substream_t *substream,
* *
* Returns zero if successful, or a negative error code on failure. * Returns zero if successful, or a negative error code on failure.
*/ */
int snd_pcm_lib_preallocate_pages_for_all(snd_pcm_t *pcm, int snd_pcm_lib_preallocate_pages_for_all(struct snd_pcm *pcm,
int type, void *data, int type, void *data,
size_t size, size_t max) size_t size, size_t max)
{ {
snd_pcm_substream_t *substream; struct snd_pcm_substream *substream;
int stream, err; int stream, err;
for (stream = 0; stream < 2; stream++) for (stream = 0; stream < 2; stream++)
...@@ -277,7 +277,7 @@ int snd_pcm_lib_preallocate_pages_for_all(snd_pcm_t *pcm, ...@@ -277,7 +277,7 @@ int snd_pcm_lib_preallocate_pages_for_all(snd_pcm_t *pcm,
* Returns the page struct at the given buffer offset. * Returns the page struct at the given buffer offset.
* Used as the page callback of PCM ops. * Used as the page callback of PCM ops.
*/ */
struct page *snd_pcm_sgbuf_ops_page(snd_pcm_substream_t *substream, unsigned long offset) struct page *snd_pcm_sgbuf_ops_page(struct snd_pcm_substream *substream, unsigned long offset)
{ {
struct snd_sg_buf *sgbuf = snd_pcm_substream_sgbuf(substream); struct snd_sg_buf *sgbuf = snd_pcm_substream_sgbuf(substream);
...@@ -298,9 +298,9 @@ struct page *snd_pcm_sgbuf_ops_page(snd_pcm_substream_t *substream, unsigned lon ...@@ -298,9 +298,9 @@ struct page *snd_pcm_sgbuf_ops_page(snd_pcm_substream_t *substream, unsigned lon
* Returns 1 if the buffer is changed, 0 if not changed, or a negative * Returns 1 if the buffer is changed, 0 if not changed, or a negative
* code on failure. * code on failure.
*/ */
int snd_pcm_lib_malloc_pages(snd_pcm_substream_t *substream, size_t size) int snd_pcm_lib_malloc_pages(struct snd_pcm_substream *substream, size_t size)
{ {
snd_pcm_runtime_t *runtime; struct snd_pcm_runtime *runtime;
struct snd_dma_buffer *dmab = NULL; struct snd_dma_buffer *dmab = NULL;
snd_assert(substream->dma_buffer.dev.type != SNDRV_DMA_TYPE_UNKNOWN, return -EINVAL); snd_assert(substream->dma_buffer.dev.type != SNDRV_DMA_TYPE_UNKNOWN, return -EINVAL);
...@@ -318,7 +318,8 @@ int snd_pcm_lib_malloc_pages(snd_pcm_substream_t *substream, size_t size) ...@@ -318,7 +318,8 @@ int snd_pcm_lib_malloc_pages(snd_pcm_substream_t *substream, size_t size)
} }
snd_pcm_lib_free_pages(substream); snd_pcm_lib_free_pages(substream);
} }
if (substream->dma_buffer.area != NULL && substream->dma_buffer.bytes >= size) { if (substream->dma_buffer.area != NULL &&
substream->dma_buffer.bytes >= size) {
dmab = &substream->dma_buffer; /* use the pre-allocated buffer */ dmab = &substream->dma_buffer; /* use the pre-allocated buffer */
} else { } else {
dmab = kzalloc(sizeof(*dmab), GFP_KERNEL); dmab = kzalloc(sizeof(*dmab), GFP_KERNEL);
...@@ -345,9 +346,9 @@ int snd_pcm_lib_malloc_pages(snd_pcm_substream_t *substream, size_t size) ...@@ -345,9 +346,9 @@ int snd_pcm_lib_malloc_pages(snd_pcm_substream_t *substream, size_t size)
* *
* Returns zero if successful, or a negative error code on failure. * Returns zero if successful, or a negative error code on failure.
*/ */
int snd_pcm_lib_free_pages(snd_pcm_substream_t *substream) int snd_pcm_lib_free_pages(struct snd_pcm_substream *substream)
{ {
snd_pcm_runtime_t *runtime; struct snd_pcm_runtime *runtime;
snd_assert(substream != NULL, return -EINVAL); snd_assert(substream != NULL, return -EINVAL);
runtime = substream->runtime; runtime = substream->runtime;
......
sound/core/pcm_misc.c
浏览文件 @ 877211f5
...@@ -441,7 +441,7 @@ snd_pcm_format_t snd_pcm_build_linear_format(int width, int unsignd, int big_end ...@@ -441,7 +441,7 @@ snd_pcm_format_t snd_pcm_build_linear_format(int width, int unsignd, int big_end
* *
* Returns zero if successful. * Returns zero if successful.
*/ */
int snd_pcm_limit_hw_rates(snd_pcm_runtime_t *runtime) int snd_pcm_limit_hw_rates(struct snd_pcm_runtime *runtime)
{ {
static unsigned rates[] = { static unsigned rates[] = {
/* ATTENTION: these values depend on the definition in pcm.h! */ /* ATTENTION: these values depend on the definition in pcm.h! */
......
sound/core/pcm_native.c
浏览文件 @ 877211f5
此差异已折叠。
sound/core/pcm_timer.c
浏览文件 @ 877211f5
...@@ -45,10 +45,10 @@ static unsigned long gcd(unsigned long a, unsigned long b) ...@@ -45,10 +45,10 @@ static unsigned long gcd(unsigned long a, unsigned long b)
return b; return b;
} }
void snd_pcm_timer_resolution_change(snd_pcm_substream_t *substream) void snd_pcm_timer_resolution_change(struct snd_pcm_substream *substream)
{ {
unsigned long rate, mult, fsize, l, post; unsigned long rate, mult, fsize, l, post;
snd_pcm_runtime_t *runtime = substream->runtime; struct snd_pcm_runtime *runtime = substream->runtime;
mult = 1000000000; mult = 1000000000;
rate = runtime->rate; rate = runtime->rate;
...@@ -74,18 +74,18 @@ void snd_pcm_timer_resolution_change(snd_pcm_substream_t *substream) ...@@ -74,18 +74,18 @@ void snd_pcm_timer_resolution_change(snd_pcm_substream_t *substream)
runtime->timer_resolution = (mult * fsize / rate) * post; runtime->timer_resolution = (mult * fsize / rate) * post;
} }
static unsigned long snd_pcm_timer_resolution(snd_timer_t * timer) static unsigned long snd_pcm_timer_resolution(struct snd_timer * timer)
{ {
snd_pcm_substream_t * substream; struct snd_pcm_substream *substream;
substream = timer->private_data; substream = timer->private_data;
return substream->runtime ? substream->runtime->timer_resolution : 0; return substream->runtime ? substream->runtime->timer_resolution : 0;
} }
static int snd_pcm_timer_start(snd_timer_t * timer) static int snd_pcm_timer_start(struct snd_timer * timer)
{ {
unsigned long flags; unsigned long flags;
snd_pcm_substream_t * substream; struct snd_pcm_substream *substream;
substream = snd_timer_chip(timer); substream = snd_timer_chip(timer);
spin_lock_irqsave(&substream->timer_lock, flags); spin_lock_irqsave(&substream->timer_lock, flags);
...@@ -94,10 +94,10 @@ static int snd_pcm_timer_start(snd_timer_t * timer) ...@@ -94,10 +94,10 @@ static int snd_pcm_timer_start(snd_timer_t * timer)
return 0; return 0;
} }
static int snd_pcm_timer_stop(snd_timer_t * timer) static int snd_pcm_timer_stop(struct snd_timer * timer)
{ {
unsigned long flags; unsigned long flags;
snd_pcm_substream_t * substream; struct snd_pcm_substream *substream;
substream = snd_timer_chip(timer); substream = snd_timer_chip(timer);
spin_lock_irqsave(&substream->timer_lock, flags); spin_lock_irqsave(&substream->timer_lock, flags);
...@@ -106,7 +106,7 @@ static int snd_pcm_timer_stop(snd_timer_t * timer) ...@@ -106,7 +106,7 @@ static int snd_pcm_timer_stop(snd_timer_t * timer)
return 0; return 0;
} }
static struct _snd_timer_hardware snd_pcm_timer = static struct snd_timer_hardware snd_pcm_timer =
{ {
.flags = SNDRV_TIMER_HW_AUTO | SNDRV_TIMER_HW_SLAVE, .flags = SNDRV_TIMER_HW_AUTO | SNDRV_TIMER_HW_SLAVE,
.resolution = 0, .resolution = 0,
...@@ -120,16 +120,16 @@ static struct _snd_timer_hardware snd_pcm_timer = ...@@ -120,16 +120,16 @@ static struct _snd_timer_hardware snd_pcm_timer =
* Init functions * Init functions
*/ */
static void snd_pcm_timer_free(snd_timer_t *timer) static void snd_pcm_timer_free(struct snd_timer *timer)
{ {
snd_pcm_substream_t *substream = timer->private_data; struct snd_pcm_substream *substream = timer->private_data;
substream->timer = NULL; substream->timer = NULL;
} }
void snd_pcm_timer_init(snd_pcm_substream_t *substream) void snd_pcm_timer_init(struct snd_pcm_substream *substream)
{ {
snd_timer_id_t tid; struct snd_timer_id tid;
snd_timer_t *timer; struct snd_timer *timer;
tid.dev_sclass = SNDRV_TIMER_SCLASS_NONE; tid.dev_sclass = SNDRV_TIMER_SCLASS_NONE;
tid.dev_class = SNDRV_TIMER_CLASS_PCM; tid.dev_class = SNDRV_TIMER_CLASS_PCM;
...@@ -152,7 +152,7 @@ void snd_pcm_timer_init(snd_pcm_substream_t *substream) ...@@ -152,7 +152,7 @@ void snd_pcm_timer_init(snd_pcm_substream_t *substream)
substream->timer = timer; substream->timer = timer;
} }
void snd_pcm_timer_done(snd_pcm_substream_t *substream) void snd_pcm_timer_done(struct snd_pcm_substream *substream)
{ {
if (substream->timer) { if (substream->timer) {
snd_device_free(substream->pcm->card, substream->timer); snd_device_free(substream->pcm->card, substream->timer);
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或