From 877211f5e1b1196179ba1290e8e1a3dc00427c55 Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Thu, 17 Nov 2005 13:59:38 +0100 Subject: [PATCH] [ALSA] Remove xxx_t typedefs: PCM Modules: PCM Midlevel Remove xxx_t typedefs from the core PCM codes. Signed-off-by: Takashi Iwai --- include/sound/pcm-indirect.h | 28 +- include/sound/pcm.h | 477 +++++++++++++-------------- include/sound/pcm_params.h | 86 ++--- sound/core/pcm.c | 214 ++++++------ sound/core/pcm_compat.c | 110 +++---- sound/core/pcm_lib.c | 320 +++++++++--------- sound/core/pcm_memory.c | 45 +-- sound/core/pcm_misc.c | 2 +- sound/core/pcm_native.c | 623 +++++++++++++++++++---------------- sound/core/pcm_timer.c | 30 +- 10 files changed, 983 insertions(+), 952 deletions(-) diff --git a/include/sound/pcm-indirect.h b/include/sound/pcm-indirect.h index 31fa7a54508a..7003d7702e26 100644 --- a/include/sound/pcm-indirect.h +++ b/include/sound/pcm-indirect.h @@ -24,7 +24,7 @@ #include -typedef struct sndrv_pcm_indirect { +struct snd_pcm_indirect { 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_data; /* Offset to next dst (or src) in hw ring buffer */ @@ -35,20 +35,20 @@ typedef struct sndrv_pcm_indirect { unsigned int sw_io; /* Current software pointer in bytes */ int sw_ready; /* Bytes ready to be transferred to/from hw */ 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, - snd_pcm_indirect_t *rec, size_t bytes); +typedef void (*snd_pcm_indirect_copy_t)(struct snd_pcm_substream *substream, + struct snd_pcm_indirect *rec, size_t bytes); /* * helper function for playback ack callback */ static inline void -snd_pcm_indirect_playback_transfer(snd_pcm_substream_t *substream, - snd_pcm_indirect_t *rec, +snd_pcm_indirect_playback_transfer(struct snd_pcm_substream *substream, + struct snd_pcm_indirect *rec, 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_sframes_t diff = appl_ptr - rec->appl_ptr; int qsize; @@ -89,8 +89,8 @@ snd_pcm_indirect_playback_transfer(snd_pcm_substream_t *substream, * ptr = current byte pointer */ static inline snd_pcm_uframes_t -snd_pcm_indirect_playback_pointer(snd_pcm_substream_t *substream, - snd_pcm_indirect_t *rec, unsigned int ptr) +snd_pcm_indirect_playback_pointer(struct snd_pcm_substream *substream, + struct snd_pcm_indirect *rec, unsigned int ptr) { int bytes = ptr - rec->hw_io; if (bytes < 0) @@ -110,11 +110,11 @@ snd_pcm_indirect_playback_pointer(snd_pcm_substream_t *substream, * helper function for capture ack callback */ static inline void -snd_pcm_indirect_capture_transfer(snd_pcm_substream_t *substream, - snd_pcm_indirect_t *rec, +snd_pcm_indirect_capture_transfer(struct snd_pcm_substream *substream, + struct snd_pcm_indirect *rec, 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_sframes_t diff = appl_ptr - rec->appl_ptr; @@ -154,8 +154,8 @@ snd_pcm_indirect_capture_transfer(snd_pcm_substream_t *substream, * ptr = current byte pointer */ static inline snd_pcm_uframes_t -snd_pcm_indirect_capture_pointer(snd_pcm_substream_t *substream, - snd_pcm_indirect_t *rec, unsigned int ptr) +snd_pcm_indirect_capture_pointer(struct snd_pcm_substream *substream, + struct snd_pcm_indirect *rec, unsigned int ptr) { int qsize; int bytes = ptr - rec->hw_io; diff --git a/include/sound/pcm.h b/include/sound/pcm.h index acc4fa9d5abe..7e77c0add80a 100644 --- a/include/sound/pcm.h +++ b/include/sound/pcm.h @@ -28,36 +28,9 @@ #include #include -typedef sndrv_pcm_uframes_t snd_pcm_uframes_t; -typedef sndrv_pcm_sframes_t snd_pcm_sframes_t; -typedef enum sndrv_pcm_class snd_pcm_class_t; -typedef enum sndrv_pcm_subclass snd_pcm_subclass_t; -typedef enum sndrv_pcm_stream snd_pcm_stream_t; -typedef enum sndrv_pcm_access snd_pcm_access_t; -typedef enum sndrv_pcm_format snd_pcm_format_t; -typedef enum sndrv_pcm_subformat snd_pcm_subformat_t; -typedef enum sndrv_pcm_state snd_pcm_state_t; -typedef union sndrv_pcm_sync_id snd_pcm_sync_id_t; -typedef struct sndrv_pcm_info snd_pcm_info_t; -typedef enum sndrv_pcm_hw_param snd_pcm_hw_param_t; -typedef struct sndrv_pcm_hw_params snd_pcm_hw_params_t; -typedef enum sndrv_pcm_start snd_pcm_start_t; -typedef enum sndrv_pcm_xrun snd_pcm_xrun_t; -typedef enum sndrv_pcm_tstamp snd_pcm_tstamp_t; -typedef struct sndrv_pcm_sw_params snd_pcm_sw_params_t; -typedef struct sndrv_pcm_channel_info snd_pcm_channel_info_t; -typedef struct sndrv_pcm_status snd_pcm_status_t; -typedef struct sndrv_pcm_mmap_status snd_pcm_mmap_status_t; -typedef struct sndrv_pcm_mmap_control snd_pcm_mmap_control_t; -typedef struct sndrv_mask snd_mask_t; -typedef struct snd_sg_buf snd_pcm_sgbuf_t; - #define snd_pcm_substream_chip(substream) ((substream)->private_data) #define snd_pcm_chip(pcm) ((pcm)->private_data) -typedef struct _snd_pcm_file snd_pcm_file_t; -typedef struct _snd_pcm_runtime snd_pcm_runtime_t; - #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE) #include "pcm_oss.h" #endif @@ -66,7 +39,7 @@ typedef struct _snd_pcm_runtime snd_pcm_runtime_t; * Hardware (lowlevel) section */ -typedef struct _snd_pcm_hardware { +struct snd_pcm_hardware { unsigned int info; /* SNDRV_PCM_INFO_* */ u64 formats; /* SNDRV_PCM_FMTBIT_* */ unsigned int rates; /* SNDRV_PCM_RATE_* */ @@ -80,26 +53,29 @@ typedef struct _snd_pcm_hardware { unsigned int periods_min; /* min # of periods */ unsigned int periods_max; /* max # of periods */ size_t fifo_size; /* fifo size in bytes */ -} snd_pcm_hardware_t; +}; -typedef struct _snd_pcm_ops { - int (*open)(snd_pcm_substream_t *substream); - int (*close)(snd_pcm_substream_t *substream); - int (*ioctl)(snd_pcm_substream_t * substream, +struct snd_pcm_ops { + int (*open)(struct snd_pcm_substream *substream); + int (*close)(struct snd_pcm_substream *substream); + int (*ioctl)(struct snd_pcm_substream * substream, unsigned int cmd, void *arg); - int (*hw_params)(snd_pcm_substream_t * substream, snd_pcm_hw_params_t * params); - int (*hw_free)(snd_pcm_substream_t *substream); - int (*prepare)(snd_pcm_substream_t * substream); - int (*trigger)(snd_pcm_substream_t * substream, int cmd); - snd_pcm_uframes_t (*pointer)(snd_pcm_substream_t * substream); - int (*copy)(snd_pcm_substream_t *substream, int channel, snd_pcm_uframes_t pos, + int (*hw_params)(struct snd_pcm_substream *substream, + struct snd_pcm_hw_params *params); + int (*hw_free)(struct snd_pcm_substream *substream); + int (*prepare)(struct snd_pcm_substream *substream); + int (*trigger)(struct snd_pcm_substream *substream, int cmd); + snd_pcm_uframes_t (*pointer)(struct snd_pcm_substream *substream); + int (*copy)(struct snd_pcm_substream *substream, int channel, + snd_pcm_uframes_t pos, void __user *buf, snd_pcm_uframes_t count); - int (*silence)(snd_pcm_substream_t *substream, int channel, + int (*silence)(struct snd_pcm_substream *substream, int channel, snd_pcm_uframes_t pos, snd_pcm_uframes_t count); - struct page *(*page)(snd_pcm_substream_t *substream, unsigned long offset); - int (*mmap)(snd_pcm_substream_t *substream, struct vm_area_struct *vma); - int (*ack)(snd_pcm_substream_t *substream); -} snd_pcm_ops_t; + struct page *(*page)(struct snd_pcm_substream *substream, + unsigned long offset); + int (*mmap)(struct snd_pcm_substream *substream, struct vm_area_struct *vma); + int (*ack)(struct snd_pcm_substream *substream); +}; /* * @@ -212,17 +188,16 @@ typedef struct _snd_pcm_ops { #define SNDRV_PCM_FMTBIT_IEC958_SUBFRAME SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_BE #endif -struct _snd_pcm_file { - snd_pcm_substream_t * substream; - struct _snd_pcm_file * next; +struct snd_pcm_file { + struct snd_pcm_substream *substream; + struct snd_pcm_file *next; }; -typedef struct _snd_pcm_hw_rule snd_pcm_hw_rule_t; +struct snd_pcm_hw_rule; +typedef int (*snd_pcm_hw_rule_func_t)(struct snd_pcm_hw_params *params, + struct snd_pcm_hw_rule *rule); -typedef int (*snd_pcm_hw_rule_func_t)(snd_pcm_hw_params_t *params, - snd_pcm_hw_rule_t *rule); - -struct _snd_pcm_hw_rule { +struct snd_pcm_hw_rule { unsigned int cond; snd_pcm_hw_rule_func_t func; int var; @@ -230,57 +205,57 @@ struct _snd_pcm_hw_rule { void *private; }; -typedef struct _snd_pcm_hw_constraints { - snd_mask_t masks[SNDRV_PCM_HW_PARAM_LAST_MASK - +struct snd_pcm_hw_constraints { + struct snd_mask masks[SNDRV_PCM_HW_PARAM_LAST_MASK - SNDRV_PCM_HW_PARAM_FIRST_MASK + 1]; - snd_interval_t intervals[SNDRV_PCM_HW_PARAM_LAST_INTERVAL - + struct snd_interval intervals[SNDRV_PCM_HW_PARAM_LAST_INTERVAL - SNDRV_PCM_HW_PARAM_FIRST_INTERVAL + 1]; unsigned int rules_num; unsigned int rules_all; - snd_pcm_hw_rule_t *rules; -} snd_pcm_hw_constraints_t; + struct snd_pcm_hw_rule *rules; +}; -static inline snd_mask_t *constrs_mask(snd_pcm_hw_constraints_t *constrs, - snd_pcm_hw_param_t var) +static inline struct snd_mask *constrs_mask(struct snd_pcm_hw_constraints *constrs, + snd_pcm_hw_param_t var) { return &constrs->masks[var - SNDRV_PCM_HW_PARAM_FIRST_MASK]; } -static inline snd_interval_t *constrs_interval(snd_pcm_hw_constraints_t *constrs, - snd_pcm_hw_param_t var) +static inline struct snd_interval *constrs_interval(struct snd_pcm_hw_constraints *constrs, + snd_pcm_hw_param_t var) { return &constrs->intervals[var - SNDRV_PCM_HW_PARAM_FIRST_INTERVAL]; } -typedef struct { +struct snd_ratnum { unsigned int num; unsigned int den_min, den_max, den_step; -} ratnum_t; +}; -typedef struct { +struct snd_ratden { unsigned int num_min, num_max, num_step; unsigned int den; -} ratden_t; +}; -typedef struct { +struct snd_pcm_hw_constraint_ratnums { int nrats; - ratnum_t *rats; -} snd_pcm_hw_constraint_ratnums_t; + struct snd_ratnum *rats; +}; -typedef struct { +struct snd_pcm_hw_constraint_ratdens { int nrats; - ratden_t *rats; -} snd_pcm_hw_constraint_ratdens_t; + struct snd_ratden *rats; +}; -typedef struct { +struct snd_pcm_hw_constraint_list { unsigned int count; unsigned int *list; unsigned int mask; -} snd_pcm_hw_constraint_list_t; +}; -struct _snd_pcm_runtime { +struct snd_pcm_runtime { /* -- Status -- */ - snd_pcm_substream_t *trigger_master; + struct snd_pcm_substream *trigger_master; struct timespec trigger_tstamp; /* trigger timestamp */ int overrange; snd_pcm_uframes_t avail_max; @@ -306,7 +281,7 @@ struct _snd_pcm_runtime { unsigned int rate_den; /* -- SW params -- */ - snd_pcm_tstamp_t tstamp_mode; /* mmap timestamp is updated */ + int tstamp_mode; /* mmap timestamp is updated */ unsigned int period_step; unsigned int sleep_min; /* min ticks to sleep */ snd_pcm_uframes_t xfer_align; /* xfer size need to be a multiple */ @@ -320,11 +295,11 @@ struct _snd_pcm_runtime { snd_pcm_uframes_t silence_start; /* starting pointer to silence area */ snd_pcm_uframes_t silence_filled; /* size filled with silence */ - snd_pcm_sync_id_t sync; /* hardware synchronization ID */ + union snd_pcm_sync_id sync; /* hardware synchronization ID */ /* -- mmap -- */ - volatile snd_pcm_mmap_status_t *status; - volatile snd_pcm_mmap_control_t *control; + volatile struct snd_pcm_mmap_status *status; + volatile struct snd_pcm_mmap_control *control; atomic_t mmap_count; /* -- locking / scheduling -- */ @@ -334,15 +309,15 @@ struct _snd_pcm_runtime { /* -- private section -- */ void *private_data; - void (*private_free)(snd_pcm_runtime_t *runtime); + void (*private_free)(struct snd_pcm_runtime *runtime); /* -- hardware description -- */ - snd_pcm_hardware_t hw; - snd_pcm_hw_constraints_t hw_constraints; + struct snd_pcm_hardware hw; + struct snd_pcm_hw_constraints hw_constraints; /* -- interrupt callbacks -- */ - void (*transfer_ack_begin)(snd_pcm_substream_t *substream); - void (*transfer_ack_end)(snd_pcm_substream_t *substream); + void (*transfer_ack_begin)(struct snd_pcm_substream *substream); + void (*transfer_ack_end)(struct snd_pcm_substream *substream); /* -- timer -- */ unsigned int timer_resolution; /* timer resolution */ @@ -356,19 +331,19 @@ struct _snd_pcm_runtime { #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE) /* -- OSS things -- */ - snd_pcm_oss_runtime_t oss; + struct snd_pcm_oss_runtime oss; #endif }; -typedef struct _snd_pcm_group { /* keep linked substreams */ +struct snd_pcm_group { /* keep linked substreams */ spinlock_t lock; struct list_head substreams; int count; -} snd_pcm_group_t; +}; -struct _snd_pcm_substream { - snd_pcm_t *pcm; - snd_pcm_str_t *pstr; +struct snd_pcm_substream { + struct snd_pcm *pcm; + struct snd_pcm_str *pstr; void *private_data; /* copied from pcm->private_data */ int number; char name[32]; /* substream name */ @@ -378,32 +353,32 @@ struct _snd_pcm_substream { unsigned int dma_buf_id; size_t dma_max; /* -- hardware operations -- */ - snd_pcm_ops_t *ops; + struct snd_pcm_ops *ops; /* -- runtime information -- */ - snd_pcm_runtime_t *runtime; + struct snd_pcm_runtime *runtime; /* -- timer section -- */ - snd_timer_t *timer; /* timer */ + struct snd_timer *timer; /* timer */ unsigned timer_running: 1; /* time is running */ spinlock_t timer_lock; /* -- next substream -- */ - snd_pcm_substream_t *next; + struct snd_pcm_substream *next; /* -- linked substreams -- */ struct list_head link_list; /* linked list member */ - snd_pcm_group_t self_group; /* fake group for non linked substream (with substream lock inside) */ - snd_pcm_group_t *group; /* pointer to current group */ + struct snd_pcm_group self_group; /* fake group for non linked substream (with substream lock inside) */ + struct snd_pcm_group *group; /* pointer to current group */ /* -- assigned files -- */ - snd_pcm_file_t *file; + struct snd_pcm_file *file; struct file *ffile; #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE) /* -- OSS things -- */ - snd_pcm_oss_substream_t oss; + struct snd_pcm_oss_substream oss; #endif - snd_info_entry_t *proc_root; - snd_info_entry_t *proc_info_entry; - snd_info_entry_t *proc_hw_params_entry; - snd_info_entry_t *proc_sw_params_entry; - snd_info_entry_t *proc_status_entry; - snd_info_entry_t *proc_prealloc_entry; + struct snd_info_entry *proc_root; + struct snd_info_entry *proc_info_entry; + struct snd_info_entry *proc_hw_params_entry; + struct snd_info_entry *proc_sw_params_entry; + struct snd_info_entry *proc_status_entry; + struct snd_info_entry *proc_prealloc_entry; /* misc flags */ unsigned int no_mmap_ctrl: 1; }; @@ -415,65 +390,65 @@ struct _snd_pcm_substream { #endif -struct _snd_pcm_str { +struct snd_pcm_str { int stream; /* stream (direction) */ - snd_pcm_t *pcm; + struct snd_pcm *pcm; /* -- substreams -- */ unsigned int substream_count; unsigned int substream_opened; - snd_pcm_substream_t *substream; + struct snd_pcm_substream *substream; #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE) /* -- OSS things -- */ - snd_pcm_oss_stream_t oss; + struct snd_pcm_oss_stream oss; #endif - snd_pcm_file_t *files; - snd_minor_t *reg; - snd_info_entry_t *proc_root; - snd_info_entry_t *proc_info_entry; + struct snd_pcm_file *files; + struct snd_minor *reg; + struct snd_info_entry *proc_root; + struct snd_info_entry *proc_info_entry; #ifdef CONFIG_SND_DEBUG unsigned int xrun_debug; /* 0 = disabled, 1 = verbose, 2 = stacktrace */ - snd_info_entry_t *proc_xrun_debug_entry; + struct snd_info_entry *proc_xrun_debug_entry; #endif }; -struct _snd_pcm { - snd_card_t *card; +struct snd_pcm { + struct snd_card *card; unsigned int device; /* device number */ unsigned int info_flags; unsigned short dev_class; unsigned short dev_subclass; char id[64]; char name[80]; - snd_pcm_str_t streams[2]; + struct snd_pcm_str streams[2]; struct semaphore open_mutex; wait_queue_head_t open_wait; void *private_data; - void (*private_free) (snd_pcm_t *pcm); + void (*private_free) (struct snd_pcm *pcm); #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE) - snd_pcm_oss_t oss; + struct snd_pcm_oss oss; #endif }; -typedef struct _snd_pcm_notify { - int (*n_register) (snd_pcm_t * pcm); - int (*n_disconnect) (snd_pcm_t * pcm); - int (*n_unregister) (snd_pcm_t * pcm); +struct snd_pcm_notify { + int (*n_register) (struct snd_pcm * pcm); + int (*n_disconnect) (struct snd_pcm * pcm); + int (*n_unregister) (struct snd_pcm * pcm); struct list_head list; -} snd_pcm_notify_t; +}; /* * Registering */ -extern snd_pcm_t *snd_pcm_devices[]; -extern snd_minor_t snd_pcm_reg[2]; +extern struct snd_pcm *snd_pcm_devices[]; +extern struct snd_minor snd_pcm_reg[2]; -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, - snd_pcm_t **rpcm); -int snd_pcm_new_stream(snd_pcm_t *pcm, int stream, int substream_count); + struct snd_pcm **rpcm); +int snd_pcm_new_stream(struct snd_pcm *pcm, int stream, int substream_count); -int snd_pcm_notify(snd_pcm_notify_t *notify, int nfree); +int snd_pcm_notify(struct snd_pcm_notify *notify, int nfree); /* * Native I/O @@ -481,24 +456,26 @@ int snd_pcm_notify(snd_pcm_notify_t *notify, int nfree); extern rwlock_t snd_pcm_link_rwlock; -int snd_pcm_info(snd_pcm_substream_t * substream, snd_pcm_info_t *info); -int snd_pcm_info_user(snd_pcm_substream_t * substream, snd_pcm_info_t __user *info); -int snd_pcm_status(snd_pcm_substream_t * substream, snd_pcm_status_t *status); -int snd_pcm_prepare(snd_pcm_substream_t *substream); -int snd_pcm_start(snd_pcm_substream_t *substream); -int snd_pcm_stop(snd_pcm_substream_t *substream, int status); -int snd_pcm_drain_done(snd_pcm_substream_t *substream); +int snd_pcm_info(struct snd_pcm_substream *substream, struct snd_pcm_info *info); +int snd_pcm_info_user(struct snd_pcm_substream *substream, + struct snd_pcm_info __user *info); +int snd_pcm_status(struct snd_pcm_substream *substream, + struct snd_pcm_status *status); +int snd_pcm_prepare(struct snd_pcm_substream *substream); +int snd_pcm_start(struct snd_pcm_substream *substream); +int snd_pcm_stop(struct snd_pcm_substream *substream, int status); +int snd_pcm_drain_done(struct snd_pcm_substream *substream); #ifdef CONFIG_PM -int snd_pcm_suspend(snd_pcm_substream_t *substream); -int snd_pcm_suspend_all(snd_pcm_t *pcm); +int snd_pcm_suspend(struct snd_pcm_substream *substream); +int snd_pcm_suspend_all(struct snd_pcm *pcm); #endif -int snd_pcm_kernel_playback_ioctl(snd_pcm_substream_t *substream, unsigned int cmd, void *arg); -int snd_pcm_kernel_capture_ioctl(snd_pcm_substream_t *substream, unsigned int cmd, void *arg); -int snd_pcm_kernel_ioctl(snd_pcm_substream_t *substream, unsigned int cmd, void *arg); -int snd_pcm_open_substream(snd_pcm_t *pcm, int stream, snd_pcm_substream_t **rsubstream); -void snd_pcm_release_substream(snd_pcm_substream_t *substream); +int snd_pcm_kernel_playback_ioctl(struct snd_pcm_substream *substream, unsigned int cmd, void *arg); +int snd_pcm_kernel_capture_ioctl(struct snd_pcm_substream *substream, unsigned int cmd, void *arg); +int snd_pcm_kernel_ioctl(struct snd_pcm_substream *substream, unsigned int cmd, void *arg); +int snd_pcm_open_substream(struct snd_pcm *pcm, int stream, struct snd_pcm_substream **rsubstream); +void snd_pcm_release_substream(struct snd_pcm_substream *substream); void snd_pcm_vma_notify_data(void *client, void *data); -int snd_pcm_mmap_data(snd_pcm_substream_t *substream, struct file *file, struct vm_area_struct *area); +int snd_pcm_mmap_data(struct snd_pcm_substream *substream, struct file *file, struct vm_area_struct *area); #if BITS_PER_LONG >= 64 @@ -578,30 +555,30 @@ static inline void div64_32(u_int64_t *n, u_int32_t div, u_int32_t *rem) * PCM library */ -static inline int snd_pcm_stream_linked(snd_pcm_substream_t *substream) +static inline int snd_pcm_stream_linked(struct snd_pcm_substream *substream) { return substream->group != &substream->self_group; } -static inline void snd_pcm_stream_lock(snd_pcm_substream_t *substream) +static inline void snd_pcm_stream_lock(struct snd_pcm_substream *substream) { read_lock(&snd_pcm_link_rwlock); spin_lock(&substream->self_group.lock); } -static inline void snd_pcm_stream_unlock(snd_pcm_substream_t *substream) +static inline void snd_pcm_stream_unlock(struct snd_pcm_substream *substream) { spin_unlock(&substream->self_group.lock); read_unlock(&snd_pcm_link_rwlock); } -static inline void snd_pcm_stream_lock_irq(snd_pcm_substream_t *substream) +static inline void snd_pcm_stream_lock_irq(struct snd_pcm_substream *substream) { read_lock_irq(&snd_pcm_link_rwlock); spin_lock(&substream->self_group.lock); } -static inline void snd_pcm_stream_unlock_irq(snd_pcm_substream_t *substream) +static inline void snd_pcm_stream_unlock_irq(struct snd_pcm_substream *substream) { spin_unlock(&substream->self_group.lock); read_unlock_irq(&snd_pcm_link_rwlock); @@ -623,56 +600,56 @@ do { \ list_for_each(pos, &substream->group->substreams) #define snd_pcm_group_substream_entry(pos) \ - list_entry(pos, snd_pcm_substream_t, link_list) + list_entry(pos, struct snd_pcm_substream, link_list) -static inline int snd_pcm_running(snd_pcm_substream_t *substream) +static inline int snd_pcm_running(struct snd_pcm_substream *substream) { return (substream->runtime->status->state == SNDRV_PCM_STATE_RUNNING || (substream->runtime->status->state == SNDRV_PCM_STATE_DRAINING && substream->stream == SNDRV_PCM_STREAM_PLAYBACK)); } -static inline ssize_t bytes_to_samples(snd_pcm_runtime_t *runtime, ssize_t size) +static inline ssize_t bytes_to_samples(struct snd_pcm_runtime *runtime, ssize_t size) { return size * 8 / runtime->sample_bits; } -static inline snd_pcm_sframes_t bytes_to_frames(snd_pcm_runtime_t *runtime, ssize_t size) +static inline snd_pcm_sframes_t bytes_to_frames(struct snd_pcm_runtime *runtime, ssize_t size) { return size * 8 / runtime->frame_bits; } -static inline ssize_t samples_to_bytes(snd_pcm_runtime_t *runtime, ssize_t size) +static inline ssize_t samples_to_bytes(struct snd_pcm_runtime *runtime, ssize_t size) { return size * runtime->sample_bits / 8; } -static inline ssize_t frames_to_bytes(snd_pcm_runtime_t *runtime, snd_pcm_sframes_t size) +static inline ssize_t frames_to_bytes(struct snd_pcm_runtime *runtime, snd_pcm_sframes_t size) { return size * runtime->frame_bits / 8; } -static inline int frame_aligned(snd_pcm_runtime_t *runtime, ssize_t bytes) +static inline int frame_aligned(struct snd_pcm_runtime *runtime, ssize_t bytes) { return bytes % runtime->byte_align == 0; } -static inline size_t snd_pcm_lib_buffer_bytes(snd_pcm_substream_t *substream) +static inline size_t snd_pcm_lib_buffer_bytes(struct snd_pcm_substream *substream) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; return frames_to_bytes(runtime, runtime->buffer_size); } -static inline size_t snd_pcm_lib_period_bytes(snd_pcm_substream_t *substream) +static inline size_t snd_pcm_lib_period_bytes(struct snd_pcm_substream *substream) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; return frames_to_bytes(runtime, runtime->period_size); } /* * result is: 0 ... (boundary - 1) */ -static inline snd_pcm_uframes_t snd_pcm_playback_avail(snd_pcm_runtime_t *runtime) +static inline snd_pcm_uframes_t snd_pcm_playback_avail(struct snd_pcm_runtime *runtime) { snd_pcm_sframes_t avail = runtime->status->hw_ptr + runtime->buffer_size - runtime->control->appl_ptr; if (avail < 0) @@ -685,7 +662,7 @@ static inline snd_pcm_uframes_t snd_pcm_playback_avail(snd_pcm_runtime_t *runtim /* * result is: 0 ... (boundary - 1) */ -static inline snd_pcm_uframes_t snd_pcm_capture_avail(snd_pcm_runtime_t *runtime) +static inline snd_pcm_uframes_t snd_pcm_capture_avail(struct snd_pcm_runtime *runtime) { snd_pcm_sframes_t avail = runtime->status->hw_ptr - runtime->control->appl_ptr; if (avail < 0) @@ -693,12 +670,12 @@ static inline snd_pcm_uframes_t snd_pcm_capture_avail(snd_pcm_runtime_t *runtime return avail; } -static inline snd_pcm_sframes_t snd_pcm_playback_hw_avail(snd_pcm_runtime_t *runtime) +static inline snd_pcm_sframes_t snd_pcm_playback_hw_avail(struct snd_pcm_runtime *runtime) { return runtime->buffer_size - snd_pcm_playback_avail(runtime); } -static inline snd_pcm_sframes_t snd_pcm_capture_hw_avail(snd_pcm_runtime_t *runtime) +static inline snd_pcm_sframes_t snd_pcm_capture_hw_avail(struct snd_pcm_runtime *runtime) { return runtime->buffer_size - snd_pcm_capture_avail(runtime); } @@ -711,9 +688,9 @@ static inline snd_pcm_sframes_t snd_pcm_capture_hw_avail(snd_pcm_runtime_t *runt * * Returns non-zero if available, or zero if not. */ -static inline int snd_pcm_playback_ready(snd_pcm_substream_t *substream) +static inline int snd_pcm_playback_ready(struct snd_pcm_substream *substream) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; return snd_pcm_playback_avail(runtime) >= runtime->control->avail_min; } @@ -725,9 +702,9 @@ static inline int snd_pcm_playback_ready(snd_pcm_substream_t *substream) * * Returns non-zero if available, or zero if not. */ -static inline int snd_pcm_capture_ready(snd_pcm_substream_t *substream) +static inline int snd_pcm_capture_ready(struct snd_pcm_substream *substream) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; return snd_pcm_capture_avail(runtime) >= runtime->control->avail_min; } @@ -740,9 +717,9 @@ static inline int snd_pcm_capture_ready(snd_pcm_substream_t *substream) * * Returns non-zero if exists, or zero if not. */ -static inline int snd_pcm_playback_data(snd_pcm_substream_t *substream) +static inline int snd_pcm_playback_data(struct snd_pcm_substream *substream) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; if (runtime->stop_threshold >= runtime->boundary) return 1; @@ -757,9 +734,9 @@ static inline int snd_pcm_playback_data(snd_pcm_substream_t *substream) * * Returns non-zero if empty, or zero if not. */ -static inline int snd_pcm_playback_empty(snd_pcm_substream_t *substream) +static inline int snd_pcm_playback_empty(struct snd_pcm_substream *substream) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; return snd_pcm_playback_avail(runtime) >= runtime->buffer_size; } @@ -771,14 +748,14 @@ static inline int snd_pcm_playback_empty(snd_pcm_substream_t *substream) * * Returns non-zero if empty, or zero if not. */ -static inline int snd_pcm_capture_empty(snd_pcm_substream_t *substream) +static inline int snd_pcm_capture_empty(struct snd_pcm_substream *substream) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; return snd_pcm_capture_avail(runtime) == 0; } -static inline void snd_pcm_trigger_done(snd_pcm_substream_t *substream, - snd_pcm_substream_t *master) +static inline void snd_pcm_trigger_done(struct snd_pcm_substream *substream, + struct snd_pcm_substream *master) { substream->runtime->trigger_master = master; } @@ -795,28 +772,28 @@ static inline int hw_is_interval(int var) var <= SNDRV_PCM_HW_PARAM_LAST_INTERVAL; } -static inline snd_mask_t *hw_param_mask(snd_pcm_hw_params_t *params, +static inline struct snd_mask *hw_param_mask(struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var) { return ¶ms->masks[var - SNDRV_PCM_HW_PARAM_FIRST_MASK]; } -static inline snd_interval_t *hw_param_interval(snd_pcm_hw_params_t *params, +static inline struct snd_interval *hw_param_interval(struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var) { return ¶ms->intervals[var - SNDRV_PCM_HW_PARAM_FIRST_INTERVAL]; } -static inline const snd_mask_t *hw_param_mask_c(const snd_pcm_hw_params_t *params, +static inline const struct snd_mask *hw_param_mask_c(const struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var) { - return (const snd_mask_t *)hw_param_mask((snd_pcm_hw_params_t*) params, var); + return (const struct snd_mask *)hw_param_mask((struct snd_pcm_hw_params*) params, var); } -static inline const snd_interval_t *hw_param_interval_c(const snd_pcm_hw_params_t *params, +static inline const struct snd_interval *hw_param_interval_c(const struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var) { - return (const snd_interval_t *)hw_param_interval((snd_pcm_hw_params_t*) params, var); + return (const struct snd_interval *)hw_param_interval((struct snd_pcm_hw_params*) params, var); } #define params_access(p) snd_mask_min(hw_param_mask((p), SNDRV_PCM_HW_PARAM_ACCESS)) @@ -832,66 +809,66 @@ static inline const snd_interval_t *hw_param_interval_c(const snd_pcm_hw_params_ #define params_tick_time(p) hw_param_interval((p), SNDRV_PCM_HW_PARAM_TICK_TIME)->min -int snd_interval_refine(snd_interval_t *i, const snd_interval_t *v); -void snd_interval_mul(const snd_interval_t *a, const snd_interval_t *b, snd_interval_t *c); -void snd_interval_div(const snd_interval_t *a, const snd_interval_t *b, snd_interval_t *c); -void snd_interval_muldivk(const snd_interval_t *a, const snd_interval_t *b, - unsigned int k, snd_interval_t *c); -void snd_interval_mulkdiv(const snd_interval_t *a, unsigned int k, - const snd_interval_t *b, snd_interval_t *c); -int snd_interval_list(snd_interval_t *i, unsigned int count, unsigned int *list, unsigned int mask); -int snd_interval_ratnum(snd_interval_t *i, - unsigned int rats_count, ratnum_t *rats, +int snd_interval_refine(struct snd_interval *i, const struct snd_interval *v); +void snd_interval_mul(const struct snd_interval *a, const struct snd_interval *b, struct snd_interval *c); +void snd_interval_div(const struct snd_interval *a, const struct snd_interval *b, struct snd_interval *c); +void snd_interval_muldivk(const struct snd_interval *a, const struct snd_interval *b, + unsigned int k, struct snd_interval *c); +void snd_interval_mulkdiv(const struct snd_interval *a, unsigned int k, + const struct snd_interval *b, struct snd_interval *c); +int snd_interval_list(struct snd_interval *i, unsigned int count, unsigned int *list, unsigned int mask); +int snd_interval_ratnum(struct snd_interval *i, + unsigned int rats_count, struct snd_ratnum *rats, unsigned int *nump, unsigned int *denp); -void _snd_pcm_hw_params_any(snd_pcm_hw_params_t *params); -void _snd_pcm_hw_param_setempty(snd_pcm_hw_params_t *params, snd_pcm_hw_param_t var); -int snd_pcm_hw_param_near(snd_pcm_substream_t *substream, - snd_pcm_hw_params_t *params, +void _snd_pcm_hw_params_any(struct snd_pcm_hw_params *params); +void _snd_pcm_hw_param_setempty(struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var); +int snd_pcm_hw_param_near(struct snd_pcm_substream *substream, + struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var, unsigned int val, int *dir); -int snd_pcm_hw_param_set(snd_pcm_substream_t *pcm, - snd_pcm_hw_params_t *params, +int snd_pcm_hw_param_set(struct snd_pcm_substream *pcm, + struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var, unsigned int val, int dir); -int snd_pcm_hw_params_choose(snd_pcm_substream_t *substream, snd_pcm_hw_params_t *params); +int snd_pcm_hw_params_choose(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params); -int snd_pcm_hw_refine(snd_pcm_substream_t *substream, snd_pcm_hw_params_t *params); +int snd_pcm_hw_refine(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params); -int snd_pcm_hw_constraints_init(snd_pcm_substream_t *substream); -int snd_pcm_hw_constraints_complete(snd_pcm_substream_t *substream); +int snd_pcm_hw_constraints_init(struct snd_pcm_substream *substream); +int snd_pcm_hw_constraints_complete(struct snd_pcm_substream *substream); -int snd_pcm_hw_constraint_mask(snd_pcm_runtime_t *runtime, snd_pcm_hw_param_t var, +int snd_pcm_hw_constraint_mask(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var, u_int32_t mask); -int snd_pcm_hw_constraint_mask64(snd_pcm_runtime_t *runtime, snd_pcm_hw_param_t var, +int snd_pcm_hw_constraint_mask64(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var, u_int64_t mask); -int snd_pcm_hw_constraint_minmax(snd_pcm_runtime_t *runtime, snd_pcm_hw_param_t var, +int snd_pcm_hw_constraint_minmax(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var, unsigned int min, unsigned int max); -int snd_pcm_hw_constraint_integer(snd_pcm_runtime_t *runtime, snd_pcm_hw_param_t var); -int snd_pcm_hw_constraint_list(snd_pcm_runtime_t *runtime, +int snd_pcm_hw_constraint_integer(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var); +int snd_pcm_hw_constraint_list(struct snd_pcm_runtime *runtime, unsigned int cond, snd_pcm_hw_param_t var, - snd_pcm_hw_constraint_list_t *l); -int snd_pcm_hw_constraint_ratnums(snd_pcm_runtime_t *runtime, + struct snd_pcm_hw_constraint_list *l); +int snd_pcm_hw_constraint_ratnums(struct snd_pcm_runtime *runtime, unsigned int cond, snd_pcm_hw_param_t var, - snd_pcm_hw_constraint_ratnums_t *r); -int snd_pcm_hw_constraint_ratdens(snd_pcm_runtime_t *runtime, + struct snd_pcm_hw_constraint_ratnums *r); +int snd_pcm_hw_constraint_ratdens(struct snd_pcm_runtime *runtime, unsigned int cond, snd_pcm_hw_param_t var, - snd_pcm_hw_constraint_ratdens_t *r); -int snd_pcm_hw_constraint_msbits(snd_pcm_runtime_t *runtime, + struct snd_pcm_hw_constraint_ratdens *r); +int snd_pcm_hw_constraint_msbits(struct snd_pcm_runtime *runtime, unsigned int cond, unsigned int width, unsigned int msbits); -int snd_pcm_hw_constraint_step(snd_pcm_runtime_t *runtime, +int snd_pcm_hw_constraint_step(struct snd_pcm_runtime *runtime, unsigned int cond, snd_pcm_hw_param_t var, unsigned long step); -int snd_pcm_hw_constraint_pow2(snd_pcm_runtime_t *runtime, +int snd_pcm_hw_constraint_pow2(struct snd_pcm_runtime *runtime, unsigned int cond, snd_pcm_hw_param_t var); -int snd_pcm_hw_rule_add(snd_pcm_runtime_t *runtime, +int snd_pcm_hw_rule_add(struct snd_pcm_runtime *runtime, unsigned int cond, int var, snd_pcm_hw_rule_func_t func, void *private, @@ -925,37 +902,37 @@ int snd_pcm_format_set_silence(snd_pcm_format_t format, void *buf, unsigned int snd_pcm_format_t snd_pcm_build_linear_format(int width, int unsignd, int big_endian); const char *snd_pcm_format_name(snd_pcm_format_t format); -void snd_pcm_set_ops(snd_pcm_t * pcm, int direction, snd_pcm_ops_t *ops); -void snd_pcm_set_sync(snd_pcm_substream_t * substream); -int snd_pcm_lib_interleave_len(snd_pcm_substream_t *substream); -int snd_pcm_lib_ioctl(snd_pcm_substream_t *substream, +void snd_pcm_set_ops(struct snd_pcm * pcm, int direction, struct snd_pcm_ops *ops); +void snd_pcm_set_sync(struct snd_pcm_substream *substream); +int snd_pcm_lib_interleave_len(struct snd_pcm_substream *substream); +int snd_pcm_lib_ioctl(struct snd_pcm_substream *substream, unsigned int cmd, void *arg); -int snd_pcm_update_hw_ptr(snd_pcm_substream_t *substream); -int snd_pcm_playback_xrun_check(snd_pcm_substream_t *substream); -int snd_pcm_capture_xrun_check(snd_pcm_substream_t *substream); -int snd_pcm_playback_xrun_asap(snd_pcm_substream_t *substream); -int snd_pcm_capture_xrun_asap(snd_pcm_substream_t *substream); -void snd_pcm_playback_silence(snd_pcm_substream_t *substream, snd_pcm_uframes_t new_hw_ptr); -void snd_pcm_tick_prepare(snd_pcm_substream_t *substream); -void snd_pcm_tick_set(snd_pcm_substream_t *substream, unsigned long ticks); -void snd_pcm_tick_elapsed(snd_pcm_substream_t *substream); -void snd_pcm_period_elapsed(snd_pcm_substream_t *substream); -snd_pcm_sframes_t snd_pcm_lib_write(snd_pcm_substream_t *substream, +int snd_pcm_update_hw_ptr(struct snd_pcm_substream *substream); +int snd_pcm_playback_xrun_check(struct snd_pcm_substream *substream); +int snd_pcm_capture_xrun_check(struct snd_pcm_substream *substream); +int snd_pcm_playback_xrun_asap(struct snd_pcm_substream *substream); +int snd_pcm_capture_xrun_asap(struct snd_pcm_substream *substream); +void snd_pcm_playback_silence(struct snd_pcm_substream *substream, snd_pcm_uframes_t new_hw_ptr); +void snd_pcm_tick_prepare(struct snd_pcm_substream *substream); +void snd_pcm_tick_set(struct snd_pcm_substream *substream, unsigned long ticks); +void snd_pcm_tick_elapsed(struct snd_pcm_substream *substream); +void snd_pcm_period_elapsed(struct snd_pcm_substream *substream); +snd_pcm_sframes_t snd_pcm_lib_write(struct snd_pcm_substream *substream, const void __user *buf, snd_pcm_uframes_t frames); -snd_pcm_sframes_t snd_pcm_lib_read(snd_pcm_substream_t *substream, +snd_pcm_sframes_t snd_pcm_lib_read(struct snd_pcm_substream *substream, void __user *buf, snd_pcm_uframes_t frames); -snd_pcm_sframes_t snd_pcm_lib_writev(snd_pcm_substream_t *substream, +snd_pcm_sframes_t snd_pcm_lib_writev(struct snd_pcm_substream *substream, void __user **bufs, snd_pcm_uframes_t frames); -snd_pcm_sframes_t snd_pcm_lib_readv(snd_pcm_substream_t *substream, +snd_pcm_sframes_t snd_pcm_lib_readv(struct snd_pcm_substream *substream, void __user **bufs, snd_pcm_uframes_t frames); -int snd_pcm_limit_hw_rates(snd_pcm_runtime_t *runtime); +int snd_pcm_limit_hw_rates(struct snd_pcm_runtime *runtime); -static inline void snd_pcm_set_runtime_buffer(snd_pcm_substream_t *substream, +static inline void snd_pcm_set_runtime_buffer(struct snd_pcm_substream *substream, struct snd_dma_buffer *bufp) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; if (bufp) { runtime->dma_buffer_p = bufp; runtime->dma_area = bufp->area; @@ -973,47 +950,47 @@ static inline void snd_pcm_set_runtime_buffer(snd_pcm_substream_t *substream, * Timer interface */ -void snd_pcm_timer_resolution_change(snd_pcm_substream_t *substream); -void snd_pcm_timer_init(snd_pcm_substream_t * substream); -void snd_pcm_timer_done(snd_pcm_substream_t * substream); +void snd_pcm_timer_resolution_change(struct snd_pcm_substream *substream); +void snd_pcm_timer_init(struct snd_pcm_substream *substream); +void snd_pcm_timer_done(struct snd_pcm_substream *substream); /* * Memory */ -int snd_pcm_lib_preallocate_free(snd_pcm_substream_t *substream); -int snd_pcm_lib_preallocate_free_for_all(snd_pcm_t *pcm); -int snd_pcm_lib_preallocate_pages(snd_pcm_substream_t *substream, +int snd_pcm_lib_preallocate_free(struct snd_pcm_substream *substream); +int snd_pcm_lib_preallocate_free_for_all(struct snd_pcm *pcm); +int snd_pcm_lib_preallocate_pages(struct snd_pcm_substream *substream, int type, struct device *data, size_t size, size_t max); -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, size_t size, size_t max); -int snd_pcm_lib_malloc_pages(snd_pcm_substream_t *substream, size_t size); -int snd_pcm_lib_free_pages(snd_pcm_substream_t *substream); +int snd_pcm_lib_malloc_pages(struct snd_pcm_substream *substream, size_t size); +int snd_pcm_lib_free_pages(struct snd_pcm_substream *substream); #define snd_pcm_substream_sgbuf(substream) ((substream)->runtime->dma_buffer_p->private_data) #define snd_pcm_sgbuf_pages(size) snd_sgbuf_aligned_pages(size) #define snd_pcm_sgbuf_get_addr(sgbuf,ofs) snd_sgbuf_get_addr(sgbuf,ofs) -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); /* handle mmap counter - PCM mmap callback should handle this counter properly */ static inline void snd_pcm_mmap_data_open(struct vm_area_struct *area) { - snd_pcm_substream_t *substream = (snd_pcm_substream_t *)area->vm_private_data; + struct snd_pcm_substream *substream = (struct snd_pcm_substream *)area->vm_private_data; atomic_inc(&substream->runtime->mmap_count); } static inline void snd_pcm_mmap_data_close(struct vm_area_struct *area) { - snd_pcm_substream_t *substream = (snd_pcm_substream_t *)area->vm_private_data; + struct snd_pcm_substream *substream = (struct snd_pcm_substream *)area->vm_private_data; atomic_dec(&substream->runtime->mmap_count); } /* mmap for io-memory area */ #if defined(CONFIG_X86) || defined(CONFIG_PPC) || defined(CONFIG_ALPHA) #define SNDRV_PCM_INFO_MMAP_IOMEM SNDRV_PCM_INFO_MMAP -int snd_pcm_lib_mmap_iomem(snd_pcm_substream_t *substream, struct vm_area_struct *area); +int snd_pcm_lib_mmap_iomem(struct snd_pcm_substream *substream, struct vm_area_struct *area); #else #define SNDRV_PCM_INFO_MMAP_IOMEM 0 #define snd_pcm_lib_mmap_iomem NULL diff --git a/include/sound/pcm_params.h b/include/sound/pcm_params.h index 60b0e92e26f3..fb18aef77341 100644 --- a/include/sound/pcm_params.h +++ b/include/sound/pcm_params.h @@ -22,17 +22,17 @@ * */ -extern int snd_pcm_hw_param_mask(snd_pcm_substream_t *pcm, snd_pcm_hw_params_t *params, - snd_pcm_hw_param_t var, const snd_mask_t *val); -extern unsigned int snd_pcm_hw_param_value_min(const 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 struct snd_mask *val); +extern unsigned int snd_pcm_hw_param_value_min(const struct snd_pcm_hw_params *params, 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); -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); -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); -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); /* To share the same code we have alsa-lib */ @@ -71,20 +71,20 @@ INLINE unsigned int ld2(u_int32_t v) 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)); } -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)); } -INLINE int snd_mask_empty(const snd_mask_t *mask) +INLINE int snd_mask_empty(const struct snd_mask *mask) { int i; for (i = 0; i < SNDRV_MASK_SIZE; i++) @@ -93,7 +93,7 @@ INLINE int snd_mask_empty(const snd_mask_t *mask) 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; assert(!snd_mask_empty(mask)); @@ -104,7 +104,7 @@ INLINE unsigned int snd_mask_min(const snd_mask_t *mask) 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; assert(!snd_mask_empty(mask)); @@ -115,19 +115,19 @@ INLINE unsigned int snd_mask_max(const snd_mask_t *mask) 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); 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); 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; 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 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; 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 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; assert(val <= SNDRV_MASK_BITS); @@ -152,30 +152,30 @@ INLINE void snd_mask_leave(snd_mask_t *mask, unsigned int val) 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; for (i = 0; i < SNDRV_MASK_SIZE; 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)); } -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; } -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); 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; assert(!snd_mask_empty(mask)); @@ -191,9 +191,9 @@ INLINE int snd_mask_single(const snd_mask_t *mask) 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)); snd_mask_copy(&old, mask); snd_mask_intersect(mask, 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); } -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)); if (snd_mask_single(mask)) @@ -211,7 +211,7 @@ INLINE int snd_mask_refine_first(snd_mask_t *mask) 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)); if (snd_mask_single(mask)) @@ -220,7 +220,7 @@ INLINE int snd_mask_refine_last(snd_mask_t *mask) 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)); if (snd_mask_min(mask) >= val) @@ -231,7 +231,7 @@ INLINE int snd_mask_refine_min(snd_mask_t *mask, unsigned int val) 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)); if (snd_mask_max(mask) <= val) @@ -242,7 +242,7 @@ INLINE int snd_mask_refine_max(snd_mask_t *mask, unsigned int val) 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; assert(!snd_mask_empty(mask)); @@ -253,13 +253,13 @@ INLINE int snd_mask_refine_set(snd_mask_t *mask, unsigned int val) 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)); 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->openmin = 0; @@ -269,42 +269,42 @@ INLINE void snd_interval_any(snd_interval_t *i) i->empty = 0; } -INLINE void snd_interval_none(snd_interval_t *i) +INLINE void snd_interval_none(struct snd_interval *i) { 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 || (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; } -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)); return (i->min == i->max || (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)); 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)); 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; assert(!snd_interval_empty(i)); @@ -314,18 +314,18 @@ INLINE int snd_interval_max(const snd_interval_t *i) 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) || 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; } -INLINE int snd_interval_setinteger(snd_interval_t *i) +INLINE int snd_interval_setinteger(struct snd_interval *i) { if (i->integer) return 0; @@ -335,7 +335,7 @@ INLINE int snd_interval_setinteger(snd_interval_t *i) 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) return i2->empty; diff --git a/sound/core/pcm.c b/sound/core/pcm.c index 184e74b75ba9..59c995bbf15b 100644 --- a/sound/core/pcm.c +++ b/sound/core/pcm.c @@ -33,18 +33,18 @@ MODULE_AUTHOR("Jaroslav Kysela , Abramo Bagnara device)) return -EFAULT; if (device >= SNDRV_PCM_DEVICES) @@ -200,7 +200,7 @@ static char *snd_pcm_tstamp_mode_names[] = { 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); return snd_pcm_stream_names[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) { - snd_assert(access <= SNDRV_PCM_ACCESS_LAST, return NULL); return snd_pcm_access_names[access]; } 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]; } 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]; } -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); return snd_pcm_tstamp_mode_names[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) { - snd_assert(state <= SNDRV_PCM_STATE_LAST, return NULL); return snd_pcm_state_names[state]; } @@ -268,9 +264,10 @@ static const char *snd_pcm_oss_format_name(int format) #endif #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; if (! substream) @@ -302,20 +299,25 @@ static void snd_pcm_proc_info_read(snd_pcm_substream_t *substream, snd_info_buff 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; - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_substream *substream = entry->private_data; + struct snd_pcm_runtime *runtime = substream->runtime; if (!runtime) { snd_iprintf(buffer, "closed\n"); return; @@ -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); } -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; - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_substream *substream = entry->private_data; + struct snd_pcm_runtime *runtime = substream->runtime; if (!runtime) { snd_iprintf(buffer, "closed\n"); return; @@ -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); } -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; - snd_pcm_runtime_t *runtime = substream->runtime; - snd_pcm_status_t status; + struct snd_pcm_substream *substream = entry->private_data; + struct snd_pcm_runtime *runtime = substream->runtime; + struct snd_pcm_status status; int err; if (!runtime) { snd_iprintf(buffer, "closed\n"); @@ -405,25 +409,27 @@ static void snd_pcm_substream_proc_status_read(snd_info_entry_t *entry, snd_info #endif #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); } -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]; if (!snd_info_get_line(buffer, line, sizeof(line))) pstr->xrun_debug = simple_strtoul(line, NULL, 10); } #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; - snd_info_entry_t *entry; + struct snd_pcm *pcm = pstr->pcm; + struct snd_info_entry *entry; char name[16]; sprintf(name, "pcm%i%c", pcm->device, @@ -447,7 +453,8 @@ static int snd_pcm_stream_proc_init(snd_pcm_str_t *pstr) pstr->proc_info_entry = entry; #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 = snd_pcm_xrun_debug_read; entry->c.text.write_size = 64; @@ -464,7 +471,7 @@ static int snd_pcm_stream_proc_init(snd_pcm_str_t *pstr) 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 if (pstr->proc_xrun_debug_entry) { @@ -483,10 +490,10 @@ static int snd_pcm_stream_proc_done(snd_pcm_str_t *pstr) 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; - snd_card_t *card; + struct snd_info_entry *entry; + struct snd_card *card; char name[16]; card = substream->pcm->card; @@ -540,7 +547,7 @@ static int snd_pcm_substream_proc_init(snd_pcm_substream_t *substream) 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) { snd_info_unregister(substream->proc_info_entry); @@ -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. */ -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; - snd_pcm_str_t *pstr = &pcm->streams[stream]; - snd_pcm_substream_t *substream, *prev; + struct snd_pcm_str *pstr = &pcm->streams[stream]; + struct snd_pcm_substream *substream, *prev; #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE) init_MUTEX(&pstr->oss.setup_mutex); @@ -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. */ -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, - snd_pcm_t ** rpcm) + struct snd_pcm ** rpcm) { - snd_pcm_t *pcm; + struct snd_pcm *pcm; int err; - static snd_device_ops_t ops = { + static struct snd_device_ops ops = { .dev_free = snd_pcm_dev_free, .dev_register = snd_pcm_dev_register, .dev_disconnect = snd_pcm_dev_disconnect, @@ -684,11 +691,11 @@ int snd_pcm_new(snd_card_t * card, char *id, int device, 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) - snd_pcm_oss_setup_t *setup, *setupn; + struct snd_pcm_oss_setup *setup, *setupn; #endif substream = pstr->substream; while (substream) { @@ -707,7 +714,7 @@ static void snd_pcm_free_stream(snd_pcm_str_t * pstr) #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); if (pcm->private_free) @@ -719,26 +726,26 @@ static int snd_pcm_free(snd_pcm_t *pcm) 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); } 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); } -int snd_pcm_open_substream(snd_pcm_t *pcm, int stream, - snd_pcm_substream_t **rsubstream) +int snd_pcm_open_substream(struct snd_pcm *pcm, int stream, + struct snd_pcm_substream **rsubstream) { - snd_pcm_str_t * pstr; - snd_pcm_substream_t * substream; - snd_pcm_runtime_t * runtime; - snd_ctl_file_t *kctl; - snd_card_t *card; + struct snd_pcm_str * pstr; + struct snd_pcm_substream *substream; + struct snd_pcm_runtime *runtime; + struct snd_ctl_file *kctl; + struct snd_card *card; struct list_head *list; int prefer_subdevice = -1; size_t size; @@ -800,7 +807,7 @@ int snd_pcm_open_substream(snd_pcm_t *pcm, int stream, if (runtime == NULL) 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); if (runtime->status == NULL) { kfree(runtime); @@ -808,10 +815,11 @@ int snd_pcm_open_substream(snd_pcm_t *pcm, int stream, } 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); 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); return -ENOMEM; } @@ -832,30 +840,32 @@ int snd_pcm_open_substream(snd_pcm_t *pcm, int stream, 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; runtime = substream->runtime; snd_assert(runtime != NULL, return); if (runtime->private_free != NULL) runtime->private_free(runtime); - snd_free_pages((void*)runtime->status, PAGE_ALIGN(sizeof(snd_pcm_mmap_status_t))); - snd_free_pages((void*)runtime->control, PAGE_ALIGN(sizeof(snd_pcm_mmap_control_t))); + snd_free_pages((void*)runtime->status, + 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); substream->runtime = NULL; 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; unsigned short minor; - snd_pcm_substream_t *substream; + struct snd_pcm_substream *substream; struct list_head *list; 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); down(®ister_mutex); @@ -890,19 +900,19 @@ static int snd_pcm_dev_register(snd_device_t *device) snd_pcm_timer_init(substream); } list_for_each(list, &snd_pcm_notify_list) { - snd_pcm_notify_t *notify; - notify = list_entry(list, snd_pcm_notify_t, list); + struct snd_pcm_notify *notify; + notify = list_entry(list, struct snd_pcm_notify, list); notify->n_register(pcm); } up(®ister_mutex); 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; - snd_pcm_substream_t *substream; + struct snd_pcm_substream *substream; int idx, cidx; down(®ister_mutex); @@ -913,20 +923,20 @@ static int snd_pcm_dev_disconnect(snd_device_t *device) if (substream->runtime) substream->runtime->status->state = SNDRV_PCM_STATE_DISCONNECTED; list_for_each(list, &snd_pcm_notify_list) { - snd_pcm_notify_t *notify; - notify = list_entry(list, snd_pcm_notify_t, list); + struct snd_pcm_notify *notify; + notify = list_entry(list, struct snd_pcm_notify, list); notify->n_disconnect(pcm); } up(®ister_mutex); 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; - snd_pcm_substream_t *substream; + struct snd_pcm_substream *substream; struct list_head *list; - snd_pcm_t *pcm = device->device_data; + struct snd_pcm *pcm = device->device_data; snd_assert(pcm != NULL, return -ENXIO); down(®ister_mutex); @@ -947,15 +957,15 @@ static int snd_pcm_dev_unregister(snd_device_t *device) snd_pcm_timer_done(substream); } list_for_each(list, &snd_pcm_notify_list) { - snd_pcm_notify_t *notify; - notify = list_entry(list, snd_pcm_notify_t, list); + struct snd_pcm_notify *notify; + notify = list_entry(list, struct snd_pcm_notify, list); notify->n_unregister(pcm); } up(®ister_mutex); 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; @@ -984,10 +994,11 @@ int snd_pcm_notify(snd_pcm_notify_t *notify, int nfree) * 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; - snd_pcm_t *pcm; + struct snd_pcm *pcm; down(®ister_mutex); 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 snd_iprintf(buffer, "%02i-%02i: %s : %s", idx / SNDRV_PCM_DEVICES, idx % SNDRV_PCM_DEVICES, pcm->id, pcm->name); 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) - 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"); } up(®ister_mutex); @@ -1009,16 +1022,17 @@ static void snd_pcm_proc_read(snd_info_entry_t *entry, snd_info_buffer_t * buffe * 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) { - snd_info_entry_t *entry; + struct snd_info_entry *entry; snd_ctl_register_ioctl(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) { - 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) { snd_info_free_entry(entry); entry = NULL; diff --git a/sound/core/pcm_compat.c b/sound/core/pcm_compat.c index 4b6307df846d..e5133033de5e 100644 --- a/sound/core/pcm_compat.c +++ b/sound/core/pcm_compat.c @@ -22,7 +22,7 @@ #include -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) { snd_pcm_sframes_t delay; @@ -39,7 +39,7 @@ static int snd_pcm_ioctl_delay_compat(snd_pcm_substream_t *substream, 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) { snd_pcm_uframes_t frames; @@ -56,7 +56,7 @@ static int snd_pcm_ioctl_rewind_compat(snd_pcm_substream_t *substream, 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) { snd_pcm_uframes_t frames; @@ -73,12 +73,12 @@ static int snd_pcm_ioctl_forward_compat(snd_pcm_substream_t *substream, return err < 0 ? err : 0; } -struct sndrv_pcm_hw_params32 { +struct snd_pcm_hw_params32 { u32 flags; - struct sndrv_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 sndrv_interval intervals[SNDRV_PCM_HW_PARAM_LAST_INTERVAL - SNDRV_PCM_HW_PARAM_FIRST_INTERVAL + 1]; - struct sndrv_interval ires[9]; /* reserved intervals */ + struct snd_mask masks[SNDRV_PCM_HW_PARAM_LAST_MASK - SNDRV_PCM_HW_PARAM_FIRST_MASK + 1]; /* this must be identical */ + struct snd_mask mres[5]; /* reserved masks */ + struct snd_interval intervals[SNDRV_PCM_HW_PARAM_LAST_INTERVAL - SNDRV_PCM_HW_PARAM_FIRST_INTERVAL + 1]; + struct snd_interval ires[9]; /* reserved intervals */ u32 rmask; u32 cmask; u32 info; @@ -89,7 +89,7 @@ struct sndrv_pcm_hw_params32 { unsigned char reserved[64]; }; -struct sndrv_pcm_sw_params32 { +struct snd_pcm_sw_params32 { s32 tstamp_mode; u32 period_step; u32 sleep_min; @@ -104,7 +104,7 @@ struct sndrv_pcm_sw_params32 { }; /* 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; @@ -116,10 +116,10 @@ static snd_pcm_uframes_t recalculate_boundary(snd_pcm_runtime_t *runtime) return boundary; } -static int snd_pcm_ioctl_sw_params_compat(snd_pcm_substream_t *substream, - struct sndrv_pcm_sw_params32 __user *src) +static int snd_pcm_ioctl_sw_params_compat(struct snd_pcm_substream *substream, + struct snd_pcm_sw_params32 __user *src) { - snd_pcm_sw_params_t params; + struct snd_pcm_sw_params params; snd_pcm_uframes_t boundary; int err; @@ -149,17 +149,17 @@ static int snd_pcm_ioctl_sw_params_compat(snd_pcm_substream_t *substream, return err; } -struct sndrv_pcm_channel_info32 { +struct snd_pcm_channel_info32 { u32 channel; u32 offset; u32 first; u32 step; }; -static int snd_pcm_ioctl_channel_info_compat(snd_pcm_substream_t *substream, - struct sndrv_pcm_channel_info32 __user *src) +static int snd_pcm_ioctl_channel_info_compat(struct snd_pcm_substream *substream, + struct snd_pcm_channel_info32 __user *src) { - snd_pcm_channel_info_t info; + struct snd_pcm_channel_info info; int err; if (get_user(info.channel, &src->channel) || @@ -178,7 +178,7 @@ static int snd_pcm_ioctl_channel_info_compat(snd_pcm_substream_t *substream, return err; } -struct sndrv_pcm_status32 { +struct snd_pcm_status32 { s32 state; struct compat_timespec trigger_tstamp; struct compat_timespec tstamp; @@ -193,10 +193,10 @@ struct sndrv_pcm_status32 { } __attribute__((packed)); -static int snd_pcm_status_user_compat(snd_pcm_substream_t *substream, - struct sndrv_pcm_status32 __user *src) +static int snd_pcm_status_user_compat(struct snd_pcm_substream *substream, + struct snd_pcm_status32 __user *src) { - snd_pcm_status_t status; + struct snd_pcm_status status; int err; err = snd_pcm_status(substream, &status); @@ -221,12 +221,12 @@ static int snd_pcm_status_user_compat(snd_pcm_substream_t *substream, } /* 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, - struct sndrv_pcm_hw_params32 __user *data32) + struct snd_pcm_hw_params32 __user *data32) { - struct sndrv_pcm_hw_params *data; - snd_pcm_runtime_t *runtime; + struct snd_pcm_hw_params *data; + struct snd_pcm_runtime *runtime; int err; if (! (runtime = substream->runtime)) @@ -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; u32 buf; u32 frames; }; -static int snd_pcm_ioctl_xferi_compat(snd_pcm_substream_t *substream, - int dir, struct sndrv_xferi32 __user *data32) +static int snd_pcm_ioctl_xferi_compat(struct snd_pcm_substream *substream, + int dir, struct snd_xferi32 __user *data32) { compat_caddr_t buf; u32 frames; @@ -303,7 +303,7 @@ static int snd_pcm_ioctl_xferi_compat(snd_pcm_substream_t *substream, /* snd_xfern needs remapping of bufs */ -struct sndrv_xfern32 { +struct snd_xfern32 { s32 result; u32 bufs; /* this is void **; */ u32 frames; @@ -315,8 +315,8 @@ struct sndrv_xfern32 { * 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. */ -static int snd_pcm_ioctl_xfern_compat(snd_pcm_substream_t *substream, - int dir, struct sndrv_xfern32 __user *data32) +static int snd_pcm_ioctl_xfern_compat(struct snd_pcm_substream *substream, + int dir, struct snd_xfern32 __user *data32) { compat_caddr_t buf; compat_caddr_t __user *bufptr; @@ -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 pad1; u32 hw_ptr; @@ -368,32 +368,32 @@ struct sndrv_pcm_mmap_status32 { s32 suspended_state; } __attribute__((packed)); -struct sndrv_pcm_mmap_control32 { +struct snd_pcm_mmap_control32 { u32 appl_ptr; u32 avail_min; }; -struct sndrv_pcm_sync_ptr32 { +struct snd_pcm_sync_ptr32 { u32 flags; union { - struct sndrv_pcm_mmap_status32 status; + struct snd_pcm_mmap_status32 status; unsigned char reserved[64]; } s; union { - struct sndrv_pcm_mmap_control32 control; + struct snd_pcm_mmap_control32 control; unsigned char reserved[64]; } c; } __attribute__((packed)); -static int snd_pcm_ioctl_sync_ptr_compat(snd_pcm_substream_t *substream, - struct sndrv_pcm_sync_ptr32 __user *src) +static int snd_pcm_ioctl_sync_ptr_compat(struct snd_pcm_substream *substream, + struct snd_pcm_sync_ptr32 __user *src) { - snd_pcm_runtime_t *runtime = substream->runtime; - volatile struct sndrv_pcm_mmap_status *status; - volatile struct sndrv_pcm_mmap_control *control; + struct snd_pcm_runtime *runtime = substream->runtime; + volatile struct snd_pcm_mmap_status *status; + volatile struct snd_pcm_mmap_control *control; u32 sflags; - struct sndrv_pcm_mmap_control scontrol; - struct sndrv_pcm_mmap_status sstatus; + struct snd_pcm_mmap_control scontrol; + struct snd_pcm_mmap_status sstatus; snd_pcm_uframes_t boundary; int err; @@ -444,26 +444,26 @@ static int snd_pcm_ioctl_sync_ptr_compat(snd_pcm_substream_t *substream, /* */ enum { - SNDRV_PCM_IOCTL_HW_REFINE32 = _IOWR('A', 0x10, struct sndrv_pcm_hw_params32), - SNDRV_PCM_IOCTL_HW_PARAMS32 = _IOWR('A', 0x11, struct sndrv_pcm_hw_params32), - SNDRV_PCM_IOCTL_SW_PARAMS32 = _IOWR('A', 0x13, struct sndrv_pcm_sw_params32), - SNDRV_PCM_IOCTL_STATUS32 = _IOR('A', 0x20, struct sndrv_pcm_status32), + SNDRV_PCM_IOCTL_HW_REFINE32 = _IOWR('A', 0x10, struct snd_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 snd_pcm_sw_params32), + SNDRV_PCM_IOCTL_STATUS32 = _IOR('A', 0x20, struct snd_pcm_status32), 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_FORWARD32 = _IOW('A', 0x49, u32), - SNDRV_PCM_IOCTL_WRITEI_FRAMES32 = _IOW('A', 0x50, struct sndrv_xferi32), - SNDRV_PCM_IOCTL_READI_FRAMES32 = _IOR('A', 0x51, struct sndrv_xferi32), - SNDRV_PCM_IOCTL_WRITEN_FRAMES32 = _IOW('A', 0x52, struct sndrv_xfern32), - SNDRV_PCM_IOCTL_READN_FRAMES32 = _IOR('A', 0x53, struct sndrv_xfern32), - SNDRV_PCM_IOCTL_SYNC_PTR32 = _IOWR('A', 0x23, struct sndrv_pcm_sync_ptr32), + SNDRV_PCM_IOCTL_WRITEI_FRAMES32 = _IOW('A', 0x50, struct snd_xferi32), + SNDRV_PCM_IOCTL_READI_FRAMES32 = _IOR('A', 0x51, struct snd_xferi32), + SNDRV_PCM_IOCTL_WRITEN_FRAMES32 = _IOW('A', 0x52, struct snd_xfern32), + SNDRV_PCM_IOCTL_READN_FRAMES32 = _IOR('A', 0x53, struct snd_xfern32), + 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) { - snd_pcm_file_t *pcm_file; - snd_pcm_substream_t *substream; + struct snd_pcm_file *pcm_file; + struct snd_pcm_substream *substream; void __user *argp = compat_ptr(arg); pcm_file = file->private_data; diff --git a/sound/core/pcm_lib.c b/sound/core/pcm_lib.c index 3dbf9bf2ac16..c58ec67d1cbf 100644 --- a/sound/core/pcm_lib.c +++ b/sound/core/pcm_lib.c @@ -39,9 +39,9 @@ * * when runtime->silence_size >= runtime->boundary - fill processed area with silence immediately */ -void snd_pcm_playback_silence(snd_pcm_substream_t *substream, snd_pcm_uframes_t new_hw_ptr) +void snd_pcm_playback_silence(struct snd_pcm_substream *substream, snd_pcm_uframes_t new_hw_ptr) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; snd_pcm_uframes_t frames, ofs, transfer; if (runtime->silence_size < runtime->boundary) { @@ -128,7 +128,7 @@ void snd_pcm_playback_silence(snd_pcm_substream_t *substream, snd_pcm_uframes_t } } -static void xrun(snd_pcm_substream_t *substream) +static void xrun(struct snd_pcm_substream *substream) { snd_pcm_stop(substream, SNDRV_PCM_STATE_XRUN); #ifdef CONFIG_SND_DEBUG @@ -143,8 +143,8 @@ static void xrun(snd_pcm_substream_t *substream) #endif } -static inline snd_pcm_uframes_t snd_pcm_update_hw_ptr_pos(snd_pcm_substream_t *substream, - snd_pcm_runtime_t *runtime) +static inline snd_pcm_uframes_t snd_pcm_update_hw_ptr_pos(struct snd_pcm_substream *substream, + struct snd_pcm_runtime *runtime) { snd_pcm_uframes_t pos; @@ -162,8 +162,8 @@ static inline snd_pcm_uframes_t snd_pcm_update_hw_ptr_pos(snd_pcm_substream_t *s return pos; } -static inline int snd_pcm_update_hw_ptr_post(snd_pcm_substream_t *substream, - snd_pcm_runtime_t *runtime) +static inline int snd_pcm_update_hw_ptr_post(struct snd_pcm_substream *substream, + struct snd_pcm_runtime *runtime) { snd_pcm_uframes_t avail; @@ -185,9 +185,9 @@ static inline int snd_pcm_update_hw_ptr_post(snd_pcm_substream_t *substream, return 0; } -static inline int snd_pcm_update_hw_ptr_interrupt(snd_pcm_substream_t *substream) +static inline int snd_pcm_update_hw_ptr_interrupt(struct snd_pcm_substream *substream) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; snd_pcm_uframes_t pos; snd_pcm_uframes_t new_hw_ptr, hw_ptr_interrupt; snd_pcm_sframes_t delta; @@ -232,9 +232,9 @@ static inline int snd_pcm_update_hw_ptr_interrupt(snd_pcm_substream_t *substream } /* CAUTION: call it with irq disabled */ -int snd_pcm_update_hw_ptr(snd_pcm_substream_t *substream) +int snd_pcm_update_hw_ptr(struct snd_pcm_substream *substream) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; snd_pcm_uframes_t pos; snd_pcm_uframes_t old_hw_ptr, new_hw_ptr; snd_pcm_sframes_t delta; @@ -281,10 +281,10 @@ int snd_pcm_update_hw_ptr(snd_pcm_substream_t *substream) * * Sets the given PCM operators to the pcm instance. */ -void snd_pcm_set_ops(snd_pcm_t *pcm, int direction, snd_pcm_ops_t *ops) +void snd_pcm_set_ops(struct snd_pcm *pcm, int direction, struct snd_pcm_ops *ops) { - snd_pcm_str_t *stream = &pcm->streams[direction]; - snd_pcm_substream_t *substream; + struct snd_pcm_str *stream = &pcm->streams[direction]; + struct snd_pcm_substream *substream; for (substream = stream->substream; substream != NULL; substream = substream->next) substream->ops = ops; @@ -297,9 +297,9 @@ void snd_pcm_set_ops(snd_pcm_t *pcm, int direction, snd_pcm_ops_t *ops) * * Sets the PCM sync identifier for the card. */ -void snd_pcm_set_sync(snd_pcm_substream_t * substream) +void snd_pcm_set_sync(struct snd_pcm_substream *substream) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; runtime->sync.id32[0] = substream->pcm->card->number; runtime->sync.id32[1] = -1; @@ -370,7 +370,7 @@ static inline unsigned int muldiv32(unsigned int a, unsigned int b, return n; } -static int snd_interval_refine_min(snd_interval_t *i, unsigned int min, int openmin) +static int snd_interval_refine_min(struct snd_interval *i, unsigned int min, int openmin) { int changed = 0; assert(!snd_interval_empty(i)); @@ -395,7 +395,7 @@ static int snd_interval_refine_min(snd_interval_t *i, unsigned int min, int open return changed; } -static int snd_interval_refine_max(snd_interval_t *i, unsigned int max, int openmax) +static int snd_interval_refine_max(struct snd_interval *i, unsigned int max, int openmax) { int changed = 0; assert(!snd_interval_empty(i)); @@ -431,7 +431,7 @@ static int snd_interval_refine_max(snd_interval_t *i, unsigned int max, int open * * Returns non-zero if the value is changed, zero if not changed. */ -int snd_interval_refine(snd_interval_t *i, const snd_interval_t *v) +int snd_interval_refine(struct snd_interval *i, const struct snd_interval *v) { int changed = 0; assert(!snd_interval_empty(i)); @@ -473,7 +473,7 @@ int snd_interval_refine(snd_interval_t *i, const snd_interval_t *v) return changed; } -static int snd_interval_refine_first(snd_interval_t *i) +static int snd_interval_refine_first(struct snd_interval *i) { assert(!snd_interval_empty(i)); if (snd_interval_single(i)) @@ -485,7 +485,7 @@ static int snd_interval_refine_first(snd_interval_t *i) return 1; } -static int snd_interval_refine_last(snd_interval_t *i) +static int snd_interval_refine_last(struct snd_interval *i) { assert(!snd_interval_empty(i)); if (snd_interval_single(i)) @@ -497,9 +497,9 @@ static int snd_interval_refine_last(snd_interval_t *i) return 1; } -static int snd_interval_refine_set(snd_interval_t *i, unsigned int val) +static int snd_interval_refine_set(struct snd_interval *i, unsigned int val) { - snd_interval_t t; + struct snd_interval t; t.empty = 0; t.min = t.max = val; t.openmin = t.openmax = 0; @@ -507,7 +507,7 @@ static int snd_interval_refine_set(snd_interval_t *i, unsigned int val) return snd_interval_refine(i, &t); } -void snd_interval_mul(const snd_interval_t *a, const snd_interval_t *b, snd_interval_t *c) +void snd_interval_mul(const struct snd_interval *a, const struct snd_interval *b, struct snd_interval *c) { if (a->empty || b->empty) { snd_interval_none(c); @@ -531,7 +531,7 @@ void snd_interval_mul(const snd_interval_t *a, const snd_interval_t *b, snd_inte * * Returns non-zero if the value is changed, zero if not changed. */ -void snd_interval_div(const snd_interval_t *a, const snd_interval_t *b, snd_interval_t *c) +void snd_interval_div(const struct snd_interval *a, const struct snd_interval *b, struct snd_interval *c) { unsigned int r; if (a->empty || b->empty) { @@ -566,8 +566,8 @@ void snd_interval_div(const snd_interval_t *a, const snd_interval_t *b, snd_inte * * Returns non-zero if the value is changed, zero if not changed. */ -void snd_interval_muldivk(const snd_interval_t *a, const snd_interval_t *b, - unsigned int k, snd_interval_t *c) +void snd_interval_muldivk(const struct snd_interval *a, const struct snd_interval *b, + unsigned int k, struct snd_interval *c) { unsigned int r; if (a->empty || b->empty) { @@ -597,8 +597,8 @@ void snd_interval_muldivk(const snd_interval_t *a, const snd_interval_t *b, * * Returns non-zero if the value is changed, zero if not changed. */ -void snd_interval_mulkdiv(const snd_interval_t *a, unsigned int k, - const snd_interval_t *b, snd_interval_t *c) +void snd_interval_mulkdiv(const struct snd_interval *a, unsigned int k, + const struct snd_interval *b, struct snd_interval *c) { unsigned int r; if (a->empty || b->empty) { @@ -636,13 +636,13 @@ void snd_interval_mulkdiv(const snd_interval_t *a, unsigned int k, * * Returns non-zero if the value is changed, zero if not changed. */ -int snd_interval_ratnum(snd_interval_t *i, - unsigned int rats_count, ratnum_t *rats, - unsigned int *nump, unsigned int *denp) +int snd_interval_ratnum(struct snd_interval *i, + unsigned int rats_count, struct snd_ratnum *rats, + unsigned int *nump, unsigned int *denp) { unsigned int best_num, best_diff, best_den; unsigned int k; - snd_interval_t t; + struct snd_interval t; int err; best_num = best_den = best_diff = 0; @@ -731,20 +731,20 @@ int snd_interval_ratnum(snd_interval_t *i, /** * snd_interval_ratden - refine the interval value * @i: interval to refine - * @rats_count: number of ratden_t - * @rats: ratden_t array + * @rats_count: number of struct ratden + * @rats: struct ratden array * @nump: pointer to store the resultant numerator * @denp: pointer to store the resultant denominator * * Returns non-zero if the value is changed, zero if not changed. */ -static int snd_interval_ratden(snd_interval_t *i, - unsigned int rats_count, ratden_t *rats, +static int snd_interval_ratden(struct snd_interval *i, + unsigned int rats_count, struct snd_ratden *rats, unsigned int *nump, unsigned int *denp) { unsigned int best_num, best_diff, best_den; unsigned int k; - snd_interval_t t; + struct snd_interval t; int err; best_num = best_den = best_diff = 0; @@ -837,7 +837,7 @@ static int snd_interval_ratden(snd_interval_t *i, * * Returns non-zero if the value is changed, zero if not changed. */ -int snd_interval_list(snd_interval_t *i, unsigned int count, unsigned int *list, unsigned int mask) +int snd_interval_list(struct snd_interval *i, unsigned int count, unsigned int *list, unsigned int mask) { unsigned int k; int changed = 0; @@ -878,7 +878,7 @@ int snd_interval_list(snd_interval_t *i, unsigned int count, unsigned int *list, return changed; } -static int snd_interval_step(snd_interval_t *i, unsigned int min, unsigned int step) +static int snd_interval_step(struct snd_interval *i, unsigned int min, unsigned int step) { unsigned int n; int changed = 0; @@ -912,18 +912,18 @@ static int snd_interval_step(snd_interval_t *i, unsigned int min, unsigned int s * * Returns zero if successful, or a negative error code on failure. */ -int snd_pcm_hw_rule_add(snd_pcm_runtime_t *runtime, unsigned int cond, +int snd_pcm_hw_rule_add(struct snd_pcm_runtime *runtime, unsigned int cond, int var, snd_pcm_hw_rule_func_t func, void *private, int dep, ...) { - snd_pcm_hw_constraints_t *constrs = &runtime->hw_constraints; - snd_pcm_hw_rule_t *c; + struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints; + struct snd_pcm_hw_rule *c; unsigned int k; va_list args; va_start(args, dep); if (constrs->rules_num >= constrs->rules_all) { - snd_pcm_hw_rule_t *new; + struct snd_pcm_hw_rule *new; unsigned int new_rules = constrs->rules_all + 16; new = kcalloc(new_rules, sizeof(*c), GFP_KERNEL); if (!new) @@ -962,11 +962,11 @@ int snd_pcm_hw_rule_add(snd_pcm_runtime_t *runtime, unsigned int cond, * * Apply the constraint of the given bitmap mask to a mask parameter. */ -int snd_pcm_hw_constraint_mask(snd_pcm_runtime_t *runtime, snd_pcm_hw_param_t var, +int snd_pcm_hw_constraint_mask(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var, u_int32_t mask) { - snd_pcm_hw_constraints_t *constrs = &runtime->hw_constraints; - snd_mask_t *maskp = constrs_mask(constrs, var); + struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints; + struct snd_mask *maskp = constrs_mask(constrs, var); *maskp->bits &= mask; memset(maskp->bits + 1, 0, (SNDRV_MASK_MAX-32) / 8); /* clear rest */ if (*maskp->bits == 0) @@ -982,11 +982,11 @@ int snd_pcm_hw_constraint_mask(snd_pcm_runtime_t *runtime, snd_pcm_hw_param_t va * * Apply the constraint of the given bitmap mask to a mask parameter. */ -int snd_pcm_hw_constraint_mask64(snd_pcm_runtime_t *runtime, snd_pcm_hw_param_t var, +int snd_pcm_hw_constraint_mask64(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var, u_int64_t mask) { - snd_pcm_hw_constraints_t *constrs = &runtime->hw_constraints; - snd_mask_t *maskp = constrs_mask(constrs, var); + struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints; + struct snd_mask *maskp = constrs_mask(constrs, var); maskp->bits[0] &= (u_int32_t)mask; maskp->bits[1] &= (u_int32_t)(mask >> 32); memset(maskp->bits + 2, 0, (SNDRV_MASK_MAX-64) / 8); /* clear rest */ @@ -1002,9 +1002,9 @@ int snd_pcm_hw_constraint_mask64(snd_pcm_runtime_t *runtime, snd_pcm_hw_param_t * * Apply the constraint of integer to an interval parameter. */ -int snd_pcm_hw_constraint_integer(snd_pcm_runtime_t *runtime, snd_pcm_hw_param_t var) +int snd_pcm_hw_constraint_integer(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var) { - snd_pcm_hw_constraints_t *constrs = &runtime->hw_constraints; + struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints; return snd_interval_setinteger(constrs_interval(constrs, var)); } @@ -1017,11 +1017,11 @@ int snd_pcm_hw_constraint_integer(snd_pcm_runtime_t *runtime, snd_pcm_hw_param_t * * Apply the min/max range constraint to an interval parameter. */ -int snd_pcm_hw_constraint_minmax(snd_pcm_runtime_t *runtime, snd_pcm_hw_param_t var, +int snd_pcm_hw_constraint_minmax(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var, unsigned int min, unsigned int max) { - snd_pcm_hw_constraints_t *constrs = &runtime->hw_constraints; - snd_interval_t t; + struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints; + struct snd_interval t; t.min = min; t.max = max; t.openmin = t.openmax = 0; @@ -1029,10 +1029,10 @@ int snd_pcm_hw_constraint_minmax(snd_pcm_runtime_t *runtime, snd_pcm_hw_param_t return snd_interval_refine(constrs_interval(constrs, var), &t); } -static int snd_pcm_hw_rule_list(snd_pcm_hw_params_t *params, - snd_pcm_hw_rule_t *rule) +static int snd_pcm_hw_rule_list(struct snd_pcm_hw_params *params, + struct snd_pcm_hw_rule *rule) { - snd_pcm_hw_constraint_list_t *list = rule->private; + struct snd_pcm_hw_constraint_list *list = rule->private; return snd_interval_list(hw_param_interval(params, rule->var), list->count, list->list, list->mask); } @@ -1046,20 +1046,20 @@ static int snd_pcm_hw_rule_list(snd_pcm_hw_params_t *params, * * Apply the list of constraints to an interval parameter. */ -int snd_pcm_hw_constraint_list(snd_pcm_runtime_t *runtime, +int snd_pcm_hw_constraint_list(struct snd_pcm_runtime *runtime, unsigned int cond, snd_pcm_hw_param_t var, - snd_pcm_hw_constraint_list_t *l) + struct snd_pcm_hw_constraint_list *l) { return snd_pcm_hw_rule_add(runtime, cond, var, snd_pcm_hw_rule_list, l, var, -1); } -static int snd_pcm_hw_rule_ratnums(snd_pcm_hw_params_t *params, - snd_pcm_hw_rule_t *rule) +static int snd_pcm_hw_rule_ratnums(struct snd_pcm_hw_params *params, + struct snd_pcm_hw_rule *rule) { - snd_pcm_hw_constraint_ratnums_t *r = rule->private; + struct snd_pcm_hw_constraint_ratnums *r = rule->private; unsigned int num = 0, den = 0; int err; err = snd_interval_ratnum(hw_param_interval(params, rule->var), @@ -1076,22 +1076,22 @@ static int snd_pcm_hw_rule_ratnums(snd_pcm_hw_params_t *params, * @runtime: PCM runtime instance * @cond: condition bits * @var: hw_params variable to apply the ratnums constraint - * @r: ratnums_t constriants + * @r: struct snd_ratnums constriants */ -int snd_pcm_hw_constraint_ratnums(snd_pcm_runtime_t *runtime, +int snd_pcm_hw_constraint_ratnums(struct snd_pcm_runtime *runtime, unsigned int cond, snd_pcm_hw_param_t var, - snd_pcm_hw_constraint_ratnums_t *r) + struct snd_pcm_hw_constraint_ratnums *r) { return snd_pcm_hw_rule_add(runtime, cond, var, snd_pcm_hw_rule_ratnums, r, var, -1); } -static int snd_pcm_hw_rule_ratdens(snd_pcm_hw_params_t *params, - snd_pcm_hw_rule_t *rule) +static int snd_pcm_hw_rule_ratdens(struct snd_pcm_hw_params *params, + struct snd_pcm_hw_rule *rule) { - snd_pcm_hw_constraint_ratdens_t *r = rule->private; + struct snd_pcm_hw_constraint_ratdens *r = rule->private; unsigned int num = 0, den = 0; int err = snd_interval_ratden(hw_param_interval(params, rule->var), r->nrats, r->rats, &num, &den); @@ -1107,25 +1107,25 @@ static int snd_pcm_hw_rule_ratdens(snd_pcm_hw_params_t *params, * @runtime: PCM runtime instance * @cond: condition bits * @var: hw_params variable to apply the ratdens constraint - * @r: ratdens_t constriants + * @r: struct snd_ratdens constriants */ -int snd_pcm_hw_constraint_ratdens(snd_pcm_runtime_t *runtime, +int snd_pcm_hw_constraint_ratdens(struct snd_pcm_runtime *runtime, unsigned int cond, snd_pcm_hw_param_t var, - snd_pcm_hw_constraint_ratdens_t *r) + struct snd_pcm_hw_constraint_ratdens *r) { return snd_pcm_hw_rule_add(runtime, cond, var, snd_pcm_hw_rule_ratdens, r, var, -1); } -static int snd_pcm_hw_rule_msbits(snd_pcm_hw_params_t *params, - snd_pcm_hw_rule_t *rule) +static int snd_pcm_hw_rule_msbits(struct snd_pcm_hw_params *params, + struct snd_pcm_hw_rule *rule) { unsigned int l = (unsigned long) rule->private; int width = l & 0xffff; unsigned int msbits = l >> 16; - snd_interval_t *i = hw_param_interval(params, SNDRV_PCM_HW_PARAM_SAMPLE_BITS); + struct snd_interval *i = hw_param_interval(params, SNDRV_PCM_HW_PARAM_SAMPLE_BITS); if (snd_interval_single(i) && snd_interval_value(i) == width) params->msbits = msbits; return 0; @@ -1138,7 +1138,7 @@ static int snd_pcm_hw_rule_msbits(snd_pcm_hw_params_t *params, * @width: sample bits width * @msbits: msbits width */ -int snd_pcm_hw_constraint_msbits(snd_pcm_runtime_t *runtime, +int snd_pcm_hw_constraint_msbits(struct snd_pcm_runtime *runtime, unsigned int cond, unsigned int width, unsigned int msbits) @@ -1150,8 +1150,8 @@ int snd_pcm_hw_constraint_msbits(snd_pcm_runtime_t *runtime, SNDRV_PCM_HW_PARAM_SAMPLE_BITS, -1); } -static int snd_pcm_hw_rule_step(snd_pcm_hw_params_t *params, - snd_pcm_hw_rule_t *rule) +static int snd_pcm_hw_rule_step(struct snd_pcm_hw_params *params, + struct snd_pcm_hw_rule *rule) { unsigned long step = (unsigned long) rule->private; return snd_interval_step(hw_param_interval(params, rule->var), 0, step); @@ -1164,7 +1164,7 @@ static int snd_pcm_hw_rule_step(snd_pcm_hw_params_t *params, * @var: hw_params variable to apply the step constraint * @step: step size */ -int snd_pcm_hw_constraint_step(snd_pcm_runtime_t *runtime, +int snd_pcm_hw_constraint_step(struct snd_pcm_runtime *runtime, unsigned int cond, snd_pcm_hw_param_t var, unsigned long step) @@ -1174,7 +1174,7 @@ int snd_pcm_hw_constraint_step(snd_pcm_runtime_t *runtime, var, -1); } -static int snd_pcm_hw_rule_pow2(snd_pcm_hw_params_t *params, snd_pcm_hw_rule_t *rule) +static int snd_pcm_hw_rule_pow2(struct snd_pcm_hw_params *params, struct snd_pcm_hw_rule *rule) { static int pow2_sizes[] = { 1<<0, 1<<1, 1<<2, 1<<3, 1<<4, 1<<5, 1<<6, 1<<7, @@ -1192,7 +1192,7 @@ static int snd_pcm_hw_rule_pow2(snd_pcm_hw_params_t *params, snd_pcm_hw_rule_t * * @cond: condition bits * @var: hw_params variable to apply the power-of-2 constraint */ -int snd_pcm_hw_constraint_pow2(snd_pcm_runtime_t *runtime, +int snd_pcm_hw_constraint_pow2(struct snd_pcm_runtime *runtime, unsigned int cond, snd_pcm_hw_param_t var) { @@ -1202,13 +1202,12 @@ int snd_pcm_hw_constraint_pow2(snd_pcm_runtime_t *runtime, } /* To use the same code we have in alsa-lib */ -#define snd_pcm_t snd_pcm_substream_t #define assert(i) snd_assert((i), return -EINVAL) #ifndef INT_MIN #define INT_MIN ((int)((unsigned int)INT_MAX+1)) #endif -static void _snd_pcm_hw_param_any(snd_pcm_hw_params_t *params, +static void _snd_pcm_hw_param_any(struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var) { if (hw_is_mask(var)) { @@ -1230,7 +1229,7 @@ static void _snd_pcm_hw_param_any(snd_pcm_hw_params_t *params, /* * snd_pcm_hw_param_any */ -int snd_pcm_hw_param_any(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, +int snd_pcm_hw_param_any(struct snd_pcm_substream *pcm, struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var) { _snd_pcm_hw_param_any(params, var); @@ -1238,7 +1237,7 @@ int snd_pcm_hw_param_any(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, } #endif /* 0 */ -void _snd_pcm_hw_params_any(snd_pcm_hw_params_t *params) +void _snd_pcm_hw_params_any(struct snd_pcm_hw_params *params) { unsigned int k; memset(params, 0, sizeof(*params)); @@ -1255,7 +1254,7 @@ void _snd_pcm_hw_params_any(snd_pcm_hw_params_t *params) * * Fill PARAMS with full configuration space boundaries */ -int snd_pcm_hw_params_any(snd_pcm_t *pcm, snd_pcm_hw_params_t *params) +int snd_pcm_hw_params_any(struct snd_pcm_substream *pcm, struct snd_pcm_hw_params *params) { _snd_pcm_hw_params_any(params); return snd_pcm_hw_refine(pcm, params); @@ -1271,11 +1270,11 @@ int snd_pcm_hw_params_any(snd_pcm_t *pcm, snd_pcm_hw_params_t *params) * Return the value for field PAR if it's fixed in configuration space * defined by PARAMS. Return -EINVAL otherwise */ -static int snd_pcm_hw_param_value(const snd_pcm_hw_params_t *params, +static int snd_pcm_hw_param_value(const struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var, int *dir) { if (hw_is_mask(var)) { - const snd_mask_t *mask = hw_param_mask_c(params, var); + const struct snd_mask *mask = hw_param_mask_c(params, var); if (!snd_mask_single(mask)) return -EINVAL; if (dir) @@ -1283,7 +1282,7 @@ static int snd_pcm_hw_param_value(const snd_pcm_hw_params_t *params, return snd_mask_value(mask); } if (hw_is_interval(var)) { - const snd_interval_t *i = hw_param_interval_c(params, var); + const struct snd_interval *i = hw_param_interval_c(params, var); if (!snd_interval_single(i)) return -EINVAL; if (dir) @@ -1302,7 +1301,7 @@ static int snd_pcm_hw_param_value(const snd_pcm_hw_params_t *params, * * Return the minimum value for field PAR. */ -unsigned int snd_pcm_hw_param_value_min(const snd_pcm_hw_params_t *params, +unsigned int snd_pcm_hw_param_value_min(const struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var, int *dir) { if (hw_is_mask(var)) { @@ -1311,7 +1310,7 @@ unsigned int snd_pcm_hw_param_value_min(const snd_pcm_hw_params_t *params, return snd_mask_min(hw_param_mask_c(params, var)); } if (hw_is_interval(var)) { - const snd_interval_t *i = hw_param_interval_c(params, var); + const struct snd_interval *i = hw_param_interval_c(params, var); if (dir) *dir = i->openmin; return snd_interval_min(i); @@ -1328,7 +1327,7 @@ unsigned int snd_pcm_hw_param_value_min(const snd_pcm_hw_params_t *params, * * Return the maximum value for field PAR. */ -unsigned int snd_pcm_hw_param_value_max(const snd_pcm_hw_params_t *params, +unsigned int snd_pcm_hw_param_value_max(const struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var, int *dir) { if (hw_is_mask(var)) { @@ -1337,7 +1336,7 @@ unsigned int snd_pcm_hw_param_value_max(const snd_pcm_hw_params_t *params, return snd_mask_max(hw_param_mask_c(params, var)); } if (hw_is_interval(var)) { - const snd_interval_t *i = hw_param_interval_c(params, var); + const struct snd_interval *i = hw_param_interval_c(params, var); if (dir) *dir = - (int) i->openmax; return snd_interval_max(i); @@ -1346,7 +1345,7 @@ unsigned int snd_pcm_hw_param_value_max(const snd_pcm_hw_params_t *params, return -EINVAL; } -void _snd_pcm_hw_param_setempty(snd_pcm_hw_params_t *params, +void _snd_pcm_hw_param_setempty(struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var) { if (hw_is_mask(var)) { @@ -1362,7 +1361,7 @@ void _snd_pcm_hw_param_setempty(snd_pcm_hw_params_t *params, } } -int _snd_pcm_hw_param_setinteger(snd_pcm_hw_params_t *params, +int _snd_pcm_hw_param_setinteger(struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var) { int changed; @@ -1383,8 +1382,8 @@ int _snd_pcm_hw_param_setinteger(snd_pcm_hw_params_t *params, * non integer values. Reduce configuration space accordingly. * Return -EINVAL if the configuration space is empty */ -int snd_pcm_hw_param_setinteger(snd_pcm_t *pcm, - snd_pcm_hw_params_t *params, +int snd_pcm_hw_param_setinteger(struct snd_pcm_substream *pcm, + struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var) { int changed = _snd_pcm_hw_param_setinteger(params, var); @@ -1399,7 +1398,7 @@ int snd_pcm_hw_param_setinteger(snd_pcm_t *pcm, } #endif /* 0 */ -static int _snd_pcm_hw_param_first(snd_pcm_hw_params_t *params, +static int _snd_pcm_hw_param_first(struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var) { int changed; @@ -1430,8 +1429,8 @@ static int _snd_pcm_hw_param_first(snd_pcm_hw_params_t *params, * values > minimum. Reduce configuration space accordingly. * Return the minimum. */ -static int snd_pcm_hw_param_first(snd_pcm_t *pcm, - snd_pcm_hw_params_t *params, +static int snd_pcm_hw_param_first(struct snd_pcm_substream *pcm, + struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var, int *dir) { int changed = _snd_pcm_hw_param_first(params, var); @@ -1444,7 +1443,7 @@ static int snd_pcm_hw_param_first(snd_pcm_t *pcm, return snd_pcm_hw_param_value(params, var, dir); } -static int _snd_pcm_hw_param_last(snd_pcm_hw_params_t *params, +static int _snd_pcm_hw_param_last(struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var) { int changed; @@ -1475,8 +1474,8 @@ static int _snd_pcm_hw_param_last(snd_pcm_hw_params_t *params, * values < maximum. Reduce configuration space accordingly. * Return the maximum. */ -static int snd_pcm_hw_param_last(snd_pcm_t *pcm, - snd_pcm_hw_params_t *params, +static int snd_pcm_hw_param_last(struct snd_pcm_substream *pcm, + struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var, int *dir) { int changed = _snd_pcm_hw_param_last(params, var); @@ -1489,7 +1488,7 @@ static int snd_pcm_hw_param_last(snd_pcm_t *pcm, return snd_pcm_hw_param_value(params, var, dir); } -int _snd_pcm_hw_param_min(snd_pcm_hw_params_t *params, +int _snd_pcm_hw_param_min(struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var, unsigned int val, int dir) { int changed; @@ -1531,7 +1530,7 @@ int _snd_pcm_hw_param_min(snd_pcm_hw_params_t *params, * values < VAL. Reduce configuration space accordingly. * Return new minimum or -EINVAL if the configuration space is empty */ -static int snd_pcm_hw_param_min(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, +static int snd_pcm_hw_param_min(struct snd_pcm_substream *pcm, struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var, unsigned int val, int *dir) { @@ -1546,7 +1545,7 @@ static int snd_pcm_hw_param_min(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, return snd_pcm_hw_param_value_min(params, var, dir); } -static int _snd_pcm_hw_param_max(snd_pcm_hw_params_t *params, +static int _snd_pcm_hw_param_max(struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var, unsigned int val, int dir) { @@ -1591,7 +1590,7 @@ static int _snd_pcm_hw_param_max(snd_pcm_hw_params_t *params, * values >= VAL + 1. Reduce configuration space accordingly. * Return new maximum or -EINVAL if the configuration space is empty */ -static int snd_pcm_hw_param_max(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, +static int snd_pcm_hw_param_max(struct snd_pcm_substream *pcm, struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var, unsigned int val, int *dir) { @@ -1606,12 +1605,12 @@ static int snd_pcm_hw_param_max(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, return snd_pcm_hw_param_value_max(params, var, dir); } -int _snd_pcm_hw_param_set(snd_pcm_hw_params_t *params, +int _snd_pcm_hw_param_set(struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var, unsigned int val, int dir) { int changed; if (hw_is_mask(var)) { - snd_mask_t *m = hw_param_mask(params, var); + struct snd_mask *m = hw_param_mask(params, var); if (val == 0 && dir < 0) { changed = -EINVAL; snd_mask_none(m); @@ -1623,14 +1622,14 @@ int _snd_pcm_hw_param_set(snd_pcm_hw_params_t *params, changed = snd_mask_refine_set(hw_param_mask(params, var), val); } } else if (hw_is_interval(var)) { - snd_interval_t *i = hw_param_interval(params, var); + struct snd_interval *i = hw_param_interval(params, var); if (val == 0 && dir < 0) { changed = -EINVAL; snd_interval_none(i); } else if (dir == 0) changed = snd_interval_refine_set(i, val); else { - snd_interval_t t; + struct snd_interval t; t.openmin = 1; t.openmax = 1; t.empty = 0; @@ -1667,7 +1666,7 @@ int _snd_pcm_hw_param_set(snd_pcm_hw_params_t *params, * values != VAL. Reduce configuration space accordingly. * Return VAL or -EINVAL if the configuration space is empty */ -int snd_pcm_hw_param_set(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, +int snd_pcm_hw_param_set(struct snd_pcm_substream *pcm, struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var, unsigned int val, int dir) { int changed = _snd_pcm_hw_param_set(params, var, val, dir); @@ -1681,8 +1680,8 @@ int snd_pcm_hw_param_set(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, return snd_pcm_hw_param_value(params, var, NULL); } -static int _snd_pcm_hw_param_mask(snd_pcm_hw_params_t *params, - snd_pcm_hw_param_t var, const snd_mask_t *val) +static int _snd_pcm_hw_param_mask(struct snd_pcm_hw_params *params, + snd_pcm_hw_param_t var, const struct snd_mask *val) { int changed; assert(hw_is_mask(var)); @@ -1708,8 +1707,8 @@ static int _snd_pcm_hw_param_mask(snd_pcm_hw_params_t *params, * Return 0 on success or -EINVAL * if the configuration space is empty */ -int snd_pcm_hw_param_mask(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, - snd_pcm_hw_param_t var, const snd_mask_t *val) +int snd_pcm_hw_param_mask(struct snd_pcm_substream *pcm, struct snd_pcm_hw_params *params, + snd_pcm_hw_param_t var, const struct snd_mask *val) { int changed = _snd_pcm_hw_param_mask(params, var, val); if (changed < 0) @@ -1784,10 +1783,10 @@ static int boundary_nearer(int min, int mindir, * SNDRV_PCM_HW_PARAM_FORMAT, SNDRV_PCM_HW_PARAM_SUBFORMAT. * Return the value found. */ -int snd_pcm_hw_param_near(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, +int snd_pcm_hw_param_near(struct snd_pcm_substream *pcm, struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var, unsigned int best, int *dir) { - snd_pcm_hw_params_t *save = NULL; + struct snd_pcm_hw_params *save = NULL; int v; unsigned int saved_min; int last = 0; @@ -1814,7 +1813,7 @@ int snd_pcm_hw_param_near(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, saved_min = min; min = snd_pcm_hw_param_min(pcm, params, var, min, &mindir); if (min >= 0) { - snd_pcm_hw_params_t *params1; + struct snd_pcm_hw_params *params1; if (max < 0) goto _end; if ((unsigned int)min == saved_min && mindir == valdir) @@ -1861,7 +1860,7 @@ int snd_pcm_hw_param_near(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, * first access, first format, first subformat, min channels, * min rate, min period time, max buffer size, min tick time */ -int snd_pcm_hw_params_choose(snd_pcm_t *pcm, snd_pcm_hw_params_t *params) +int snd_pcm_hw_params_choose(struct snd_pcm_substream *pcm, struct snd_pcm_hw_params *params) { int err; @@ -1892,13 +1891,12 @@ int snd_pcm_hw_params_choose(snd_pcm_t *pcm, snd_pcm_hw_params_t *params) return 0; } -#undef snd_pcm_t #undef assert -static int snd_pcm_lib_ioctl_reset(snd_pcm_substream_t *substream, +static int snd_pcm_lib_ioctl_reset(struct snd_pcm_substream *substream, void *arg) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; unsigned long flags; snd_pcm_stream_lock_irqsave(substream, flags); if (snd_pcm_running(substream) && @@ -1910,11 +1908,11 @@ static int snd_pcm_lib_ioctl_reset(snd_pcm_substream_t *substream, return 0; } -static int snd_pcm_lib_ioctl_channel_info(snd_pcm_substream_t *substream, +static int snd_pcm_lib_ioctl_channel_info(struct snd_pcm_substream *substream, void *arg) { - snd_pcm_channel_info_t *info = arg; - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_channel_info *info = arg; + struct snd_pcm_runtime *runtime = substream->runtime; int width; if (!(runtime->info & SNDRV_PCM_INFO_MMAP)) { info->offset = -1; @@ -1956,7 +1954,7 @@ static int snd_pcm_lib_ioctl_channel_info(snd_pcm_substream_t *substream, * * Returns zero if successful, or a negative error code on failure. */ -int snd_pcm_lib_ioctl(snd_pcm_substream_t *substream, +int snd_pcm_lib_ioctl(struct snd_pcm_substream *substream, unsigned int cmd, void *arg) { switch (cmd) { @@ -1974,10 +1972,10 @@ int snd_pcm_lib_ioctl(snd_pcm_substream_t *substream, * Conditions */ -static void snd_pcm_system_tick_set(snd_pcm_substream_t *substream, +static void snd_pcm_system_tick_set(struct snd_pcm_substream *substream, unsigned long ticks) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; if (ticks == 0) del_timer(&runtime->tick_timer); else { @@ -1988,14 +1986,14 @@ static void snd_pcm_system_tick_set(snd_pcm_substream_t *substream, } /* Temporary alias */ -void snd_pcm_tick_set(snd_pcm_substream_t *substream, unsigned long ticks) +void snd_pcm_tick_set(struct snd_pcm_substream *substream, unsigned long ticks) { snd_pcm_system_tick_set(substream, ticks); } -void snd_pcm_tick_prepare(snd_pcm_substream_t *substream) +void snd_pcm_tick_prepare(struct snd_pcm_substream *substream) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; snd_pcm_uframes_t frames = ULONG_MAX; snd_pcm_uframes_t avail, dist; unsigned int ticks; @@ -2046,9 +2044,9 @@ void snd_pcm_tick_prepare(snd_pcm_substream_t *substream) snd_pcm_tick_set(substream, (unsigned long) ticks); } -void snd_pcm_tick_elapsed(snd_pcm_substream_t *substream) +void snd_pcm_tick_elapsed(struct snd_pcm_substream *substream) { - snd_pcm_runtime_t *runtime; + struct snd_pcm_runtime *runtime; unsigned long flags; snd_assert(substream != NULL, return); @@ -2076,9 +2074,9 @@ void snd_pcm_tick_elapsed(snd_pcm_substream_t *substream) * Even if more than one periods have elapsed since the last call, you * have to call this only once. */ -void snd_pcm_period_elapsed(snd_pcm_substream_t *substream) +void snd_pcm_period_elapsed(struct snd_pcm_substream *substream) { - snd_pcm_runtime_t *runtime; + struct snd_pcm_runtime *runtime; unsigned long flags; snd_assert(substream != NULL, return); @@ -2104,12 +2102,12 @@ void snd_pcm_period_elapsed(snd_pcm_substream_t *substream) kill_fasync(&runtime->fasync, SIGIO, POLL_IN); } -static int snd_pcm_lib_write_transfer(snd_pcm_substream_t *substream, +static int snd_pcm_lib_write_transfer(struct snd_pcm_substream *substream, unsigned int hwoff, unsigned long data, unsigned int off, snd_pcm_uframes_t frames) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; int err; char __user *buf = (char __user *) data + frames_to_bytes(runtime, off); if (substream->ops->copy) { @@ -2124,17 +2122,17 @@ static int snd_pcm_lib_write_transfer(snd_pcm_substream_t *substream, return 0; } -typedef int (*transfer_f)(snd_pcm_substream_t *substream, unsigned int hwoff, +typedef int (*transfer_f)(struct snd_pcm_substream *substream, unsigned int hwoff, unsigned long data, unsigned int off, snd_pcm_uframes_t size); -static snd_pcm_sframes_t snd_pcm_lib_write1(snd_pcm_substream_t *substream, +static snd_pcm_sframes_t snd_pcm_lib_write1(struct snd_pcm_substream *substream, unsigned long data, snd_pcm_uframes_t size, int nonblock, transfer_f transfer) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; snd_pcm_uframes_t xfer = 0; snd_pcm_uframes_t offset = 0; int err = 0; @@ -2290,9 +2288,9 @@ static snd_pcm_sframes_t snd_pcm_lib_write1(snd_pcm_substream_t *substream, return xfer > 0 ? (snd_pcm_sframes_t)xfer : err; } -snd_pcm_sframes_t snd_pcm_lib_write(snd_pcm_substream_t *substream, const void __user *buf, snd_pcm_uframes_t size) +snd_pcm_sframes_t snd_pcm_lib_write(struct snd_pcm_substream *substream, const void __user *buf, snd_pcm_uframes_t size) { - snd_pcm_runtime_t *runtime; + struct snd_pcm_runtime *runtime; int nonblock; snd_assert(substream != NULL, return -ENXIO); @@ -2306,7 +2304,7 @@ snd_pcm_sframes_t snd_pcm_lib_write(snd_pcm_substream_t *substream, const void _ nonblock = !!(substream->ffile->f_flags & O_NONBLOCK); #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE) if (substream->oss.oss) { - snd_pcm_oss_setup_t *setup = substream->oss.setup; + struct snd_pcm_oss_setup *setup = substream->oss.setup; if (setup != NULL) { if (setup->nonblock) nonblock = 1; @@ -2323,12 +2321,12 @@ snd_pcm_sframes_t snd_pcm_lib_write(snd_pcm_substream_t *substream, const void _ snd_pcm_lib_write_transfer); } -static int snd_pcm_lib_writev_transfer(snd_pcm_substream_t *substream, +static int snd_pcm_lib_writev_transfer(struct snd_pcm_substream *substream, unsigned int hwoff, unsigned long data, unsigned int off, snd_pcm_uframes_t frames) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; int err; void __user **bufs = (void __user **)data; int channels = runtime->channels; @@ -2363,11 +2361,11 @@ static int snd_pcm_lib_writev_transfer(snd_pcm_substream_t *substream, return 0; } -snd_pcm_sframes_t snd_pcm_lib_writev(snd_pcm_substream_t *substream, +snd_pcm_sframes_t snd_pcm_lib_writev(struct snd_pcm_substream *substream, void __user **bufs, snd_pcm_uframes_t frames) { - snd_pcm_runtime_t *runtime; + struct snd_pcm_runtime *runtime; int nonblock; snd_assert(substream != NULL, return -ENXIO); @@ -2381,7 +2379,7 @@ snd_pcm_sframes_t snd_pcm_lib_writev(snd_pcm_substream_t *substream, nonblock = !!(substream->ffile->f_flags & O_NONBLOCK); #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE) if (substream->oss.oss) { - snd_pcm_oss_setup_t *setup = substream->oss.setup; + struct snd_pcm_oss_setup *setup = substream->oss.setup; if (setup != NULL) { if (setup->nonblock) nonblock = 1; @@ -2397,12 +2395,12 @@ snd_pcm_sframes_t snd_pcm_lib_writev(snd_pcm_substream_t *substream, nonblock, snd_pcm_lib_writev_transfer); } -static int snd_pcm_lib_read_transfer(snd_pcm_substream_t *substream, +static int snd_pcm_lib_read_transfer(struct snd_pcm_substream *substream, unsigned int hwoff, unsigned long data, unsigned int off, snd_pcm_uframes_t frames) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; int err; char __user *buf = (char __user *) data + frames_to_bytes(runtime, off); if (substream->ops->copy) { @@ -2417,13 +2415,13 @@ static int snd_pcm_lib_read_transfer(snd_pcm_substream_t *substream, return 0; } -static snd_pcm_sframes_t snd_pcm_lib_read1(snd_pcm_substream_t *substream, +static snd_pcm_sframes_t snd_pcm_lib_read1(struct snd_pcm_substream *substream, unsigned long data, snd_pcm_uframes_t size, int nonblock, transfer_f transfer) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; snd_pcm_uframes_t xfer = 0; snd_pcm_uframes_t offset = 0; int err = 0; @@ -2587,9 +2585,9 @@ static snd_pcm_sframes_t snd_pcm_lib_read1(snd_pcm_substream_t *substream, return xfer > 0 ? (snd_pcm_sframes_t)xfer : err; } -snd_pcm_sframes_t snd_pcm_lib_read(snd_pcm_substream_t *substream, void __user *buf, snd_pcm_uframes_t size) +snd_pcm_sframes_t snd_pcm_lib_read(struct snd_pcm_substream *substream, void __user *buf, snd_pcm_uframes_t size) { - snd_pcm_runtime_t *runtime; + struct snd_pcm_runtime *runtime; int nonblock; snd_assert(substream != NULL, return -ENXIO); @@ -2603,7 +2601,7 @@ snd_pcm_sframes_t snd_pcm_lib_read(snd_pcm_substream_t *substream, void __user * nonblock = !!(substream->ffile->f_flags & O_NONBLOCK); #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE) if (substream->oss.oss) { - snd_pcm_oss_setup_t *setup = substream->oss.setup; + struct snd_pcm_oss_setup *setup = substream->oss.setup; if (setup != NULL) { if (setup->nonblock) nonblock = 1; @@ -2617,12 +2615,12 @@ snd_pcm_sframes_t snd_pcm_lib_read(snd_pcm_substream_t *substream, void __user * return snd_pcm_lib_read1(substream, (unsigned long)buf, size, nonblock, snd_pcm_lib_read_transfer); } -static int snd_pcm_lib_readv_transfer(snd_pcm_substream_t *substream, +static int snd_pcm_lib_readv_transfer(struct snd_pcm_substream *substream, unsigned int hwoff, unsigned long data, unsigned int off, snd_pcm_uframes_t frames) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; int err; void __user **bufs = (void __user **)data; int channels = runtime->channels; @@ -2654,11 +2652,11 @@ static int snd_pcm_lib_readv_transfer(snd_pcm_substream_t *substream, return 0; } -snd_pcm_sframes_t snd_pcm_lib_readv(snd_pcm_substream_t *substream, +snd_pcm_sframes_t snd_pcm_lib_readv(struct snd_pcm_substream *substream, void __user **bufs, snd_pcm_uframes_t frames) { - snd_pcm_runtime_t *runtime; + struct snd_pcm_runtime *runtime; int nonblock; snd_assert(substream != NULL, return -ENXIO); @@ -2672,7 +2670,7 @@ snd_pcm_sframes_t snd_pcm_lib_readv(snd_pcm_substream_t *substream, nonblock = !!(substream->ffile->f_flags & O_NONBLOCK); #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE) if (substream->oss.oss) { - snd_pcm_oss_setup_t *setup = substream->oss.setup; + struct snd_pcm_oss_setup *setup = substream->oss.setup; if (setup != NULL) { if (setup->nonblock) nonblock = 1; diff --git a/sound/core/pcm_memory.c b/sound/core/pcm_memory.c index b3f5344f60be..d37bcb761884 100644 --- a/sound/core/pcm_memory.c +++ b/sound/core/pcm_memory.c @@ -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. */ -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; int err; @@ -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. */ -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) return; @@ -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. */ -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); if (substream->proc_prealloc_entry) { @@ -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. */ -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; for (stream = 0; stream < 2; stream++) @@ -131,10 +131,10 @@ int snd_pcm_lib_preallocate_free_for_all(snd_pcm_t *pcm) * * prints the current allocated size in kB. */ -static void snd_pcm_lib_preallocate_proc_read(snd_info_entry_t *entry, - snd_info_buffer_t *buffer) +static void snd_pcm_lib_preallocate_proc_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_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, * * accepts the preallocation size in kB. */ -static void snd_pcm_lib_preallocate_proc_write(snd_info_entry_t *entry, - snd_info_buffer_t *buffer) +static void snd_pcm_lib_preallocate_proc_write(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; char line[64], str[64]; size_t size; struct snd_dma_buffer new_dmab; @@ -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 */ -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) { - snd_info_entry_t *entry; + struct snd_info_entry *entry; if (size > 0 && preallocate_dma && substream->number < maximum_substreams) preallocate_pcm_pages(substream, size); @@ -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. */ -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, size_t size, size_t max) { @@ -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. */ -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, size_t size, size_t max) { - snd_pcm_substream_t *substream; + struct snd_pcm_substream *substream; int stream, err; for (stream = 0; stream < 2; stream++) @@ -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. * 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); @@ -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 * 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; 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) } 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 */ } else { dmab = kzalloc(sizeof(*dmab), GFP_KERNEL); @@ -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. */ -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); runtime = substream->runtime; diff --git a/sound/core/pcm_misc.c b/sound/core/pcm_misc.c index 1453743e4da0..593c77f4d181 100644 --- a/sound/core/pcm_misc.c +++ b/sound/core/pcm_misc.c @@ -441,7 +441,7 @@ snd_pcm_format_t snd_pcm_build_linear_format(int width, int unsignd, int big_end * * 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[] = { /* ATTENTION: these values depend on the definition in pcm.h! */ diff --git a/sound/core/pcm_native.c b/sound/core/pcm_native.c index 16e252f54954..263c01a70fdd 100644 --- a/sound/core/pcm_native.c +++ b/sound/core/pcm_native.c @@ -39,11 +39,11 @@ * Compatibility */ -struct sndrv_pcm_hw_params_old { +struct snd_pcm_hw_params_old { unsigned int flags; unsigned int masks[SNDRV_PCM_HW_PARAM_SUBFORMAT - SNDRV_PCM_HW_PARAM_ACCESS + 1]; - struct sndrv_interval intervals[SNDRV_PCM_HW_PARAM_TICK_TIME - + struct snd_interval intervals[SNDRV_PCM_HW_PARAM_TICK_TIME - SNDRV_PCM_HW_PARAM_SAMPLE_BITS + 1]; unsigned int rmask; unsigned int cmask; @@ -51,15 +51,17 @@ struct sndrv_pcm_hw_params_old { unsigned int msbits; unsigned int rate_num; unsigned int rate_den; - sndrv_pcm_uframes_t fifo_size; + snd_pcm_uframes_t fifo_size; unsigned char reserved[64]; }; -#define SNDRV_PCM_IOCTL_HW_REFINE_OLD _IOWR('A', 0x10, struct sndrv_pcm_hw_params_old) -#define SNDRV_PCM_IOCTL_HW_PARAMS_OLD _IOWR('A', 0x11, struct sndrv_pcm_hw_params_old) +#define SNDRV_PCM_IOCTL_HW_REFINE_OLD _IOWR('A', 0x10, struct snd_pcm_hw_params_old) +#define SNDRV_PCM_IOCTL_HW_PARAMS_OLD _IOWR('A', 0x11, struct snd_pcm_hw_params_old) -static int snd_pcm_hw_refine_old_user(snd_pcm_substream_t * substream, struct sndrv_pcm_hw_params_old __user * _oparams); -static int snd_pcm_hw_params_old_user(snd_pcm_substream_t * substream, struct sndrv_pcm_hw_params_old __user * _oparams); +static int snd_pcm_hw_refine_old_user(struct snd_pcm_substream *substream, + struct snd_pcm_hw_params_old __user * _oparams); +static int snd_pcm_hw_params_old_user(struct snd_pcm_substream *substream, + struct snd_pcm_hw_params_old __user * _oparams); /* * @@ -83,11 +85,11 @@ static inline void snd_leave_user(mm_segment_t fs) -int snd_pcm_info(snd_pcm_substream_t * substream, snd_pcm_info_t *info) +int snd_pcm_info(struct snd_pcm_substream *substream, struct snd_pcm_info *info) { - snd_pcm_runtime_t * runtime; - snd_pcm_t *pcm = substream->pcm; - snd_pcm_str_t *pstr = substream->pstr; + struct snd_pcm_runtime *runtime; + struct snd_pcm *pcm = substream->pcm; + struct snd_pcm_str *pstr = substream->pstr; snd_assert(substream != NULL, return -ENXIO); memset(info, 0, sizeof(*info)); @@ -111,9 +113,10 @@ int snd_pcm_info(snd_pcm_substream_t * substream, snd_pcm_info_t *info) return 0; } -int snd_pcm_info_user(snd_pcm_substream_t * substream, snd_pcm_info_t __user * _info) +int snd_pcm_info_user(struct snd_pcm_substream *substream, + struct snd_pcm_info __user * _info) { - snd_pcm_info_t *info; + struct snd_pcm_info *info; int err; info = kmalloc(sizeof(*info), GFP_KERNEL); @@ -151,14 +154,14 @@ char *snd_pcm_hw_param_names[] = { }; #endif -int snd_pcm_hw_refine(snd_pcm_substream_t *substream, - snd_pcm_hw_params_t *params) +int snd_pcm_hw_refine(struct snd_pcm_substream *substream, + struct snd_pcm_hw_params *params) { unsigned int k; - snd_pcm_hardware_t *hw; - snd_interval_t *i = NULL; - snd_mask_t *m = NULL; - snd_pcm_hw_constraints_t *constrs = &substream->runtime->hw_constraints; + struct snd_pcm_hardware *hw; + struct snd_interval *i = NULL; + struct snd_mask *m = NULL; + struct snd_pcm_hw_constraints *constrs = &substream->runtime->hw_constraints; unsigned int rstamps[constrs->rules_num]; unsigned int vstamps[SNDRV_PCM_HW_PARAM_LAST_INTERVAL + 1]; unsigned int stamp = 2; @@ -231,7 +234,7 @@ int snd_pcm_hw_refine(snd_pcm_substream_t *substream, do { again = 0; for (k = 0; k < constrs->rules_num; k++) { - snd_pcm_hw_rule_t *r = &constrs->rules[k]; + struct snd_pcm_hw_rule *r = &constrs->rules[k]; unsigned int d; int doit = 0; if (r->cond && !(r->cond & params->flags)) @@ -313,9 +316,10 @@ int snd_pcm_hw_refine(snd_pcm_substream_t *substream, return 0; } -static int snd_pcm_hw_refine_user(snd_pcm_substream_t * substream, snd_pcm_hw_params_t __user * _params) +static int snd_pcm_hw_refine_user(struct snd_pcm_substream *substream, + struct snd_pcm_hw_params __user * _params) { - snd_pcm_hw_params_t *params; + struct snd_pcm_hw_params *params; int err; params = kmalloc(sizeof(*params), GFP_KERNEL); @@ -337,10 +341,10 @@ out: return err; } -static int snd_pcm_hw_params(snd_pcm_substream_t *substream, - snd_pcm_hw_params_t *params) +static int snd_pcm_hw_params(struct snd_pcm_substream *substream, + struct snd_pcm_hw_params *params) { - snd_pcm_runtime_t *runtime; + struct snd_pcm_runtime *runtime; int err; unsigned int bits; snd_pcm_uframes_t frames; @@ -432,9 +436,10 @@ static int snd_pcm_hw_params(snd_pcm_substream_t *substream, return err; } -static int snd_pcm_hw_params_user(snd_pcm_substream_t * substream, snd_pcm_hw_params_t __user * _params) +static int snd_pcm_hw_params_user(struct snd_pcm_substream *substream, + struct snd_pcm_hw_params __user * _params) { - snd_pcm_hw_params_t *params; + struct snd_pcm_hw_params *params; int err; params = kmalloc(sizeof(*params), GFP_KERNEL); @@ -456,9 +461,9 @@ out: return err; } -static int snd_pcm_hw_free(snd_pcm_substream_t * substream) +static int snd_pcm_hw_free(struct snd_pcm_substream *substream) { - snd_pcm_runtime_t *runtime; + struct snd_pcm_runtime *runtime; int result = 0; snd_assert(substream != NULL, return -ENXIO); @@ -482,9 +487,10 @@ static int snd_pcm_hw_free(snd_pcm_substream_t * substream) return result; } -static int snd_pcm_sw_params(snd_pcm_substream_t * substream, snd_pcm_sw_params_t *params) +static int snd_pcm_sw_params(struct snd_pcm_substream *substream, + struct snd_pcm_sw_params *params) { - snd_pcm_runtime_t *runtime; + struct snd_pcm_runtime *runtime; snd_assert(substream != NULL, return -ENXIO); runtime = substream->runtime; @@ -537,9 +543,10 @@ static int snd_pcm_sw_params(snd_pcm_substream_t * substream, snd_pcm_sw_params_ return 0; } -static int snd_pcm_sw_params_user(snd_pcm_substream_t * substream, snd_pcm_sw_params_t __user * _params) +static int snd_pcm_sw_params_user(struct snd_pcm_substream *substream, + struct snd_pcm_sw_params __user * _params) { - snd_pcm_sw_params_t params; + struct snd_pcm_sw_params params; int err; if (copy_from_user(¶ms, _params, sizeof(params))) return -EFAULT; @@ -549,10 +556,10 @@ static int snd_pcm_sw_params_user(snd_pcm_substream_t * substream, snd_pcm_sw_pa return err; } -int snd_pcm_status(snd_pcm_substream_t *substream, - snd_pcm_status_t *status) +int snd_pcm_status(struct snd_pcm_substream *substream, + struct snd_pcm_status *status) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; snd_pcm_stream_lock_irq(substream); status->state = runtime->status->state; @@ -593,10 +600,11 @@ int snd_pcm_status(snd_pcm_substream_t *substream, return 0; } -static int snd_pcm_status_user(snd_pcm_substream_t * substream, snd_pcm_status_t __user * _status) +static int snd_pcm_status_user(struct snd_pcm_substream *substream, + struct snd_pcm_status __user * _status) { - snd_pcm_status_t status; - snd_pcm_runtime_t *runtime; + struct snd_pcm_status status; + struct snd_pcm_runtime *runtime; int res; snd_assert(substream != NULL, return -ENXIO); @@ -610,9 +618,10 @@ static int snd_pcm_status_user(snd_pcm_substream_t * substream, snd_pcm_status_t return 0; } -static int snd_pcm_channel_info(snd_pcm_substream_t * substream, snd_pcm_channel_info_t * info) +static int snd_pcm_channel_info(struct snd_pcm_substream *substream, + struct snd_pcm_channel_info * info) { - snd_pcm_runtime_t *runtime; + struct snd_pcm_runtime *runtime; unsigned int channel; snd_assert(substream != NULL, return -ENXIO); @@ -631,9 +640,10 @@ static int snd_pcm_channel_info(snd_pcm_substream_t * substream, snd_pcm_channel return substream->ops->ioctl(substream, SNDRV_PCM_IOCTL1_CHANNEL_INFO, info); } -static int snd_pcm_channel_info_user(snd_pcm_substream_t * substream, snd_pcm_channel_info_t __user * _info) +static int snd_pcm_channel_info_user(struct snd_pcm_substream *substream, + struct snd_pcm_channel_info __user * _info) { - snd_pcm_channel_info_t info; + struct snd_pcm_channel_info info; int res; if (copy_from_user(&info, _info, sizeof(info))) @@ -646,9 +656,9 @@ static int snd_pcm_channel_info_user(snd_pcm_substream_t * substream, snd_pcm_ch return 0; } -static void snd_pcm_trigger_tstamp(snd_pcm_substream_t *substream) +static void snd_pcm_trigger_tstamp(struct snd_pcm_substream *substream) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; if (runtime->trigger_master == NULL) return; if (runtime->trigger_master == substream) { @@ -661,10 +671,10 @@ static void snd_pcm_trigger_tstamp(snd_pcm_substream_t *substream) } struct action_ops { - int (*pre_action)(snd_pcm_substream_t *substream, int state); - int (*do_action)(snd_pcm_substream_t *substream, int state); - void (*undo_action)(snd_pcm_substream_t *substream, int state); - void (*post_action)(snd_pcm_substream_t *substream, int state); + int (*pre_action)(struct snd_pcm_substream *substream, int state); + int (*do_action)(struct snd_pcm_substream *substream, int state); + void (*undo_action)(struct snd_pcm_substream *substream, int state); + void (*post_action)(struct snd_pcm_substream *substream, int state); }; /* @@ -673,12 +683,12 @@ struct action_ops { * Note2: call with calling stream lock + link lock */ static int snd_pcm_action_group(struct action_ops *ops, - snd_pcm_substream_t *substream, + struct snd_pcm_substream *substream, int state, int do_lock) { struct list_head *pos; - snd_pcm_substream_t *s = NULL; - snd_pcm_substream_t *s1; + struct snd_pcm_substream *s = NULL; + struct snd_pcm_substream *s1; int res = 0; snd_pcm_group_for_each(pos, substream) { @@ -727,7 +737,7 @@ static int snd_pcm_action_group(struct action_ops *ops, * Note: call with stream lock */ static int snd_pcm_action_single(struct action_ops *ops, - snd_pcm_substream_t *substream, + struct snd_pcm_substream *substream, int state) { int res; @@ -747,7 +757,7 @@ static int snd_pcm_action_single(struct action_ops *ops, * Note: call with stream lock */ static int snd_pcm_action(struct action_ops *ops, - snd_pcm_substream_t *substream, + struct snd_pcm_substream *substream, int state) { int res; @@ -770,7 +780,7 @@ static int snd_pcm_action(struct action_ops *ops, * Note: don't use any locks before */ static int snd_pcm_action_lock_irq(struct action_ops *ops, - snd_pcm_substream_t *substream, + struct snd_pcm_substream *substream, int state) { int res; @@ -794,7 +804,7 @@ static int snd_pcm_action_lock_irq(struct action_ops *ops, /* */ static int snd_pcm_action_nonatomic(struct action_ops *ops, - snd_pcm_substream_t *substream, + struct snd_pcm_substream *substream, int state) { int res; @@ -811,9 +821,9 @@ static int snd_pcm_action_nonatomic(struct action_ops *ops, /* * start callbacks */ -static int snd_pcm_pre_start(snd_pcm_substream_t *substream, int state) +static int snd_pcm_pre_start(struct snd_pcm_substream *substream, int state) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; if (runtime->status->state != SNDRV_PCM_STATE_PREPARED) return -EBADFD; if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK && @@ -823,22 +833,22 @@ static int snd_pcm_pre_start(snd_pcm_substream_t *substream, int state) return 0; } -static int snd_pcm_do_start(snd_pcm_substream_t *substream, int state) +static int snd_pcm_do_start(struct snd_pcm_substream *substream, int state) { if (substream->runtime->trigger_master != substream) return 0; return substream->ops->trigger(substream, SNDRV_PCM_TRIGGER_START); } -static void snd_pcm_undo_start(snd_pcm_substream_t *substream, int state) +static void snd_pcm_undo_start(struct snd_pcm_substream *substream, int state) { if (substream->runtime->trigger_master == substream) substream->ops->trigger(substream, SNDRV_PCM_TRIGGER_STOP); } -static void snd_pcm_post_start(snd_pcm_substream_t *substream, int state) +static void snd_pcm_post_start(struct snd_pcm_substream *substream, int state) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; snd_pcm_trigger_tstamp(substream); runtime->status->state = state; if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK && @@ -847,7 +857,8 @@ static void snd_pcm_post_start(snd_pcm_substream_t *substream, int state) if (runtime->sleep_min) snd_pcm_tick_prepare(substream); if (substream->timer) - snd_timer_notify(substream->timer, SNDRV_TIMER_EVENT_MSTART, &runtime->trigger_tstamp); + snd_timer_notify(substream->timer, SNDRV_TIMER_EVENT_MSTART, + &runtime->trigger_tstamp); } static struct action_ops snd_pcm_action_start = { @@ -863,24 +874,25 @@ static struct action_ops snd_pcm_action_start = { * * Start all linked streams. */ -int snd_pcm_start(snd_pcm_substream_t *substream) +int snd_pcm_start(struct snd_pcm_substream *substream) { - return snd_pcm_action(&snd_pcm_action_start, substream, SNDRV_PCM_STATE_RUNNING); + return snd_pcm_action(&snd_pcm_action_start, substream, + SNDRV_PCM_STATE_RUNNING); } /* * stop callbacks */ -static int snd_pcm_pre_stop(snd_pcm_substream_t *substream, int state) +static int snd_pcm_pre_stop(struct snd_pcm_substream *substream, int state) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; if (runtime->status->state == SNDRV_PCM_STATE_OPEN) return -EBADFD; runtime->trigger_master = substream; return 0; } -static int snd_pcm_do_stop(snd_pcm_substream_t *substream, int state) +static int snd_pcm_do_stop(struct snd_pcm_substream *substream, int state) { if (substream->runtime->trigger_master == substream && snd_pcm_running(substream)) @@ -888,13 +900,14 @@ static int snd_pcm_do_stop(snd_pcm_substream_t *substream, int state) return 0; /* unconditonally stop all substreams */ } -static void snd_pcm_post_stop(snd_pcm_substream_t *substream, int state) +static void snd_pcm_post_stop(struct snd_pcm_substream *substream, int state) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; if (runtime->status->state != state) { snd_pcm_trigger_tstamp(substream); if (substream->timer) - snd_timer_notify(substream->timer, SNDRV_TIMER_EVENT_MSTOP, &runtime->trigger_tstamp); + snd_timer_notify(substream->timer, SNDRV_TIMER_EVENT_MSTOP, + &runtime->trigger_tstamp); runtime->status->state = state; snd_pcm_tick_set(substream, 0); } @@ -915,7 +928,7 @@ static struct action_ops snd_pcm_action_stop = { * Try to stop all running streams in the substream group. * The state of each stream is changed to the given value after that unconditionally. */ -int snd_pcm_stop(snd_pcm_substream_t *substream, int state) +int snd_pcm_stop(struct snd_pcm_substream *substream, int state) { return snd_pcm_action(&snd_pcm_action_stop, substream, state); } @@ -928,17 +941,18 @@ int snd_pcm_stop(snd_pcm_substream_t *substream, int state) * The state is changed to SETUP. * Unlike snd_pcm_stop(), this affects only the given stream. */ -int snd_pcm_drain_done(snd_pcm_substream_t *substream) +int snd_pcm_drain_done(struct snd_pcm_substream *substream) { - return snd_pcm_action_single(&snd_pcm_action_stop, substream, SNDRV_PCM_STATE_SETUP); + return snd_pcm_action_single(&snd_pcm_action_stop, substream, + SNDRV_PCM_STATE_SETUP); } /* * pause callbacks */ -static int snd_pcm_pre_pause(snd_pcm_substream_t *substream, int push) +static int snd_pcm_pre_pause(struct snd_pcm_substream *substream, int push) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; if (!(runtime->info & SNDRV_PCM_INFO_PAUSE)) return -ENOSYS; if (push) { @@ -950,7 +964,7 @@ static int snd_pcm_pre_pause(snd_pcm_substream_t *substream, int push) return 0; } -static int snd_pcm_do_pause(snd_pcm_substream_t *substream, int push) +static int snd_pcm_do_pause(struct snd_pcm_substream *substream, int push) { if (substream->runtime->trigger_master != substream) return 0; @@ -959,7 +973,7 @@ static int snd_pcm_do_pause(snd_pcm_substream_t *substream, int push) SNDRV_PCM_TRIGGER_PAUSE_RELEASE); } -static void snd_pcm_undo_pause(snd_pcm_substream_t *substream, int push) +static void snd_pcm_undo_pause(struct snd_pcm_substream *substream, int push) { if (substream->runtime->trigger_master == substream) substream->ops->trigger(substream, @@ -967,14 +981,16 @@ static void snd_pcm_undo_pause(snd_pcm_substream_t *substream, int push) SNDRV_PCM_TRIGGER_PAUSE_PUSH); } -static void snd_pcm_post_pause(snd_pcm_substream_t *substream, int push) +static void snd_pcm_post_pause(struct snd_pcm_substream *substream, int push) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; snd_pcm_trigger_tstamp(substream); if (push) { runtime->status->state = SNDRV_PCM_STATE_PAUSED; if (substream->timer) - snd_timer_notify(substream->timer, SNDRV_TIMER_EVENT_MPAUSE, &runtime->trigger_tstamp); + snd_timer_notify(substream->timer, + SNDRV_TIMER_EVENT_MPAUSE, + &runtime->trigger_tstamp); snd_pcm_tick_set(substream, 0); wake_up(&runtime->sleep); } else { @@ -982,7 +998,9 @@ static void snd_pcm_post_pause(snd_pcm_substream_t *substream, int push) if (runtime->sleep_min) snd_pcm_tick_prepare(substream); if (substream->timer) - snd_timer_notify(substream->timer, SNDRV_TIMER_EVENT_MCONTINUE, &runtime->trigger_tstamp); + snd_timer_notify(substream->timer, + SNDRV_TIMER_EVENT_MCONTINUE, + &runtime->trigger_tstamp); } } @@ -996,7 +1014,7 @@ static struct action_ops snd_pcm_action_pause = { /* * Push/release the pause for all linked streams. */ -static int snd_pcm_pause(snd_pcm_substream_t *substream, int push) +static int snd_pcm_pause(struct snd_pcm_substream *substream, int push) { return snd_pcm_action(&snd_pcm_action_pause, substream, push); } @@ -1004,18 +1022,18 @@ static int snd_pcm_pause(snd_pcm_substream_t *substream, int push) #ifdef CONFIG_PM /* suspend */ -static int snd_pcm_pre_suspend(snd_pcm_substream_t *substream, int state) +static int snd_pcm_pre_suspend(struct snd_pcm_substream *substream, int state) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; if (runtime->status->state == SNDRV_PCM_STATE_SUSPENDED) return -EBUSY; runtime->trigger_master = substream; return 0; } -static int snd_pcm_do_suspend(snd_pcm_substream_t *substream, int state) +static int snd_pcm_do_suspend(struct snd_pcm_substream *substream, int state) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; if (runtime->trigger_master != substream) return 0; if (! snd_pcm_running(substream)) @@ -1024,12 +1042,13 @@ static int snd_pcm_do_suspend(snd_pcm_substream_t *substream, int state) return 0; /* suspend unconditionally */ } -static void snd_pcm_post_suspend(snd_pcm_substream_t *substream, int state) +static void snd_pcm_post_suspend(struct snd_pcm_substream *substream, int state) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; snd_pcm_trigger_tstamp(substream); if (substream->timer) - snd_timer_notify(substream->timer, SNDRV_TIMER_EVENT_MSUSPEND, &runtime->trigger_tstamp); + snd_timer_notify(substream->timer, SNDRV_TIMER_EVENT_MSUSPEND, + &runtime->trigger_tstamp); runtime->status->suspended_state = runtime->status->state; runtime->status->state = SNDRV_PCM_STATE_SUSPENDED; snd_pcm_tick_set(substream, 0); @@ -1049,7 +1068,7 @@ static struct action_ops snd_pcm_action_suspend = { * Trigger SUSPEND to all linked streams. * After this call, all streams are changed to SUSPENDED state. */ -int snd_pcm_suspend(snd_pcm_substream_t *substream) +int snd_pcm_suspend(struct snd_pcm_substream *substream) { int err; unsigned long flags; @@ -1067,13 +1086,14 @@ int snd_pcm_suspend(snd_pcm_substream_t *substream) * Trigger SUSPEND to all substreams in the given pcm. * After this call, all streams are changed to SUSPENDED state. */ -int snd_pcm_suspend_all(snd_pcm_t *pcm) +int snd_pcm_suspend_all(struct snd_pcm *pcm) { - snd_pcm_substream_t *substream; + struct snd_pcm_substream *substream; int stream, err = 0; for (stream = 0; stream < 2; stream++) { - for (substream = pcm->streams[stream].substream; substream; substream = substream->next) { + for (substream = pcm->streams[stream].substream; + substream; substream = substream->next) { /* FIXME: the open/close code should lock this as well */ if (substream->runtime == NULL) continue; @@ -1087,18 +1107,18 @@ int snd_pcm_suspend_all(snd_pcm_t *pcm) /* resume */ -static int snd_pcm_pre_resume(snd_pcm_substream_t *substream, int state) +static int snd_pcm_pre_resume(struct snd_pcm_substream *substream, int state) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; if (!(runtime->info & SNDRV_PCM_INFO_RESUME)) return -ENOSYS; runtime->trigger_master = substream; return 0; } -static int snd_pcm_do_resume(snd_pcm_substream_t *substream, int state) +static int snd_pcm_do_resume(struct snd_pcm_substream *substream, int state) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; if (runtime->trigger_master != substream) return 0; /* DMA not running previously? */ @@ -1109,19 +1129,20 @@ static int snd_pcm_do_resume(snd_pcm_substream_t *substream, int state) return substream->ops->trigger(substream, SNDRV_PCM_TRIGGER_RESUME); } -static void snd_pcm_undo_resume(snd_pcm_substream_t *substream, int state) +static void snd_pcm_undo_resume(struct snd_pcm_substream *substream, int state) { if (substream->runtime->trigger_master == substream && snd_pcm_running(substream)) substream->ops->trigger(substream, SNDRV_PCM_TRIGGER_SUSPEND); } -static void snd_pcm_post_resume(snd_pcm_substream_t *substream, int state) +static void snd_pcm_post_resume(struct snd_pcm_substream *substream, int state) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; snd_pcm_trigger_tstamp(substream); if (substream->timer) - snd_timer_notify(substream->timer, SNDRV_TIMER_EVENT_MRESUME, &runtime->trigger_tstamp); + snd_timer_notify(substream->timer, SNDRV_TIMER_EVENT_MRESUME, + &runtime->trigger_tstamp); runtime->status->state = runtime->status->suspended_state; if (runtime->sleep_min) snd_pcm_tick_prepare(substream); @@ -1134,9 +1155,9 @@ static struct action_ops snd_pcm_action_resume = { .post_action = snd_pcm_post_resume }; -static int snd_pcm_resume(snd_pcm_substream_t *substream) +static int snd_pcm_resume(struct snd_pcm_substream *substream) { - snd_card_t *card = substream->pcm->card; + struct snd_card *card = substream->pcm->card; int res; snd_power_lock(card); @@ -1148,7 +1169,7 @@ static int snd_pcm_resume(snd_pcm_substream_t *substream) #else -static int snd_pcm_resume(snd_pcm_substream_t *substream) +static int snd_pcm_resume(struct snd_pcm_substream *substream) { return -ENOSYS; } @@ -1160,10 +1181,10 @@ static int snd_pcm_resume(snd_pcm_substream_t *substream) * * Change the RUNNING stream(s) to XRUN state. */ -static int snd_pcm_xrun(snd_pcm_substream_t *substream) +static int snd_pcm_xrun(struct snd_pcm_substream *substream) { - snd_card_t *card = substream->pcm->card; - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_card *card = substream->pcm->card; + struct snd_pcm_runtime *runtime = substream->runtime; int result; snd_power_lock(card); @@ -1193,9 +1214,9 @@ static int snd_pcm_xrun(snd_pcm_substream_t *substream) /* * reset ioctl */ -static int snd_pcm_pre_reset(snd_pcm_substream_t * substream, int state) +static int snd_pcm_pre_reset(struct snd_pcm_substream *substream, int state) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; switch (runtime->status->state) { case SNDRV_PCM_STATE_RUNNING: case SNDRV_PCM_STATE_PREPARED: @@ -1207,23 +1228,24 @@ static int snd_pcm_pre_reset(snd_pcm_substream_t * substream, int state) } } -static int snd_pcm_do_reset(snd_pcm_substream_t * substream, int state) +static int snd_pcm_do_reset(struct snd_pcm_substream *substream, int state) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; int err = substream->ops->ioctl(substream, SNDRV_PCM_IOCTL1_RESET, NULL); if (err < 0) return err; // snd_assert(runtime->status->hw_ptr < runtime->buffer_size, ); runtime->hw_ptr_base = 0; - runtime->hw_ptr_interrupt = runtime->status->hw_ptr - runtime->status->hw_ptr % runtime->period_size; + runtime->hw_ptr_interrupt = runtime->status->hw_ptr - + runtime->status->hw_ptr % runtime->period_size; runtime->silence_start = runtime->status->hw_ptr; runtime->silence_filled = 0; return 0; } -static void snd_pcm_post_reset(snd_pcm_substream_t * substream, int state) +static void snd_pcm_post_reset(struct snd_pcm_substream *substream, int state) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; runtime->control->appl_ptr = runtime->status->hw_ptr; if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK && runtime->silence_size > 0) @@ -1236,7 +1258,7 @@ static struct action_ops snd_pcm_action_reset = { .post_action = snd_pcm_post_reset }; -static int snd_pcm_reset(snd_pcm_substream_t *substream) +static int snd_pcm_reset(struct snd_pcm_substream *substream) { return snd_pcm_action_nonatomic(&snd_pcm_action_reset, substream, 0); } @@ -1244,9 +1266,9 @@ static int snd_pcm_reset(snd_pcm_substream_t *substream) /* * prepare ioctl */ -static int snd_pcm_pre_prepare(snd_pcm_substream_t * substream, int state) +static int snd_pcm_pre_prepare(struct snd_pcm_substream *substream, int state) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; if (runtime->status->state == SNDRV_PCM_STATE_OPEN) return -EBADFD; if (snd_pcm_running(substream)) @@ -1254,7 +1276,7 @@ static int snd_pcm_pre_prepare(snd_pcm_substream_t * substream, int state) return 0; } -static int snd_pcm_do_prepare(snd_pcm_substream_t * substream, int state) +static int snd_pcm_do_prepare(struct snd_pcm_substream *substream, int state) { int err; err = substream->ops->prepare(substream); @@ -1263,9 +1285,9 @@ static int snd_pcm_do_prepare(snd_pcm_substream_t * substream, int state) return snd_pcm_do_reset(substream, 0); } -static void snd_pcm_post_prepare(snd_pcm_substream_t * substream, int state) +static void snd_pcm_post_prepare(struct snd_pcm_substream *substream, int state) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; runtime->control->appl_ptr = runtime->status->hw_ptr; runtime->status->state = SNDRV_PCM_STATE_PREPARED; } @@ -1282,10 +1304,10 @@ static struct action_ops snd_pcm_action_prepare = { * * Prepare the PCM substream to be triggerable. */ -int snd_pcm_prepare(snd_pcm_substream_t *substream) +int snd_pcm_prepare(struct snd_pcm_substream *substream) { int res; - snd_card_t *card = substream->pcm->card; + struct snd_card *card = substream->pcm->card; snd_power_lock(card); if ((res = snd_power_wait(card, SNDRV_CTL_POWER_D0, substream->ffile)) >= 0) @@ -1298,7 +1320,7 @@ int snd_pcm_prepare(snd_pcm_substream_t *substream) * drain ioctl */ -static int snd_pcm_pre_drain_init(snd_pcm_substream_t * substream, int state) +static int snd_pcm_pre_drain_init(struct snd_pcm_substream *substream, int state) { if (substream->ffile->f_flags & O_NONBLOCK) return -EAGAIN; @@ -1306,9 +1328,9 @@ static int snd_pcm_pre_drain_init(snd_pcm_substream_t * substream, int state) return 0; } -static int snd_pcm_do_drain_init(snd_pcm_substream_t * substream, int state) +static int snd_pcm_do_drain_init(struct snd_pcm_substream *substream, int state) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { switch (runtime->status->state) { case SNDRV_PCM_STATE_PREPARED: @@ -1336,7 +1358,7 @@ static int snd_pcm_do_drain_init(snd_pcm_substream_t * substream, int state) return 0; } -static void snd_pcm_post_drain_init(snd_pcm_substream_t * substream, int state) +static void snd_pcm_post_drain_init(struct snd_pcm_substream *substream, int state) { } @@ -1347,12 +1369,12 @@ static struct action_ops snd_pcm_action_drain_init = { }; struct drain_rec { - snd_pcm_substream_t *substream; + struct snd_pcm_substream *substream; wait_queue_t wait; snd_pcm_uframes_t stop_threshold; }; -static int snd_pcm_drop(snd_pcm_substream_t *substream); +static int snd_pcm_drop(struct snd_pcm_substream *substream); /* * Drain the stream(s). @@ -1361,10 +1383,10 @@ static int snd_pcm_drop(snd_pcm_substream_t *substream); * After this call, all streams are supposed to be either SETUP or DRAINING * (capture only) state. */ -static int snd_pcm_drain(snd_pcm_substream_t *substream) +static int snd_pcm_drain(struct snd_pcm_substream *substream) { - snd_card_t *card; - snd_pcm_runtime_t *runtime; + struct snd_card *card; + struct snd_pcm_runtime *runtime; struct list_head *pos; int result = 0; int i, num_drecs; @@ -1401,7 +1423,7 @@ static int snd_pcm_drain(snd_pcm_substream_t *substream) /* count only playback streams */ num_drecs = 0; snd_pcm_group_for_each(pos, substream) { - snd_pcm_substream_t *s = snd_pcm_group_substream_entry(pos); + struct snd_pcm_substream *s = snd_pcm_group_substream_entry(pos); runtime = s->runtime; if (s->stream == SNDRV_PCM_STREAM_PLAYBACK) { d = &drec[num_drecs++]; @@ -1487,10 +1509,10 @@ static int snd_pcm_drain(snd_pcm_substream_t *substream) * * Immediately put all linked substreams into SETUP state. */ -static int snd_pcm_drop(snd_pcm_substream_t *substream) +static int snd_pcm_drop(struct snd_pcm_substream *substream) { - snd_pcm_runtime_t *runtime; - snd_card_t *card; + struct snd_pcm_runtime *runtime; + struct snd_card *card; int result = 0; snd_assert(substream != NULL, return -ENXIO); @@ -1548,12 +1570,12 @@ static struct file *snd_pcm_file_fd(int fd) /* * PCM link handling */ -static int snd_pcm_link(snd_pcm_substream_t *substream, int fd) +static int snd_pcm_link(struct snd_pcm_substream *substream, int fd) { int res = 0; struct file *file; - snd_pcm_file_t *pcm_file; - snd_pcm_substream_t *substream1; + struct snd_pcm_file *pcm_file; + struct snd_pcm_substream *substream1; file = snd_pcm_file_fd(fd); if (!file) @@ -1572,7 +1594,7 @@ static int snd_pcm_link(snd_pcm_substream_t *substream, int fd) goto _end; } if (!snd_pcm_stream_linked(substream)) { - substream->group = kmalloc(sizeof(snd_pcm_group_t), GFP_ATOMIC); + substream->group = kmalloc(sizeof(struct snd_pcm_group), GFP_ATOMIC); if (substream->group == NULL) { res = -ENOMEM; goto _end; @@ -1592,14 +1614,14 @@ static int snd_pcm_link(snd_pcm_substream_t *substream, int fd) return res; } -static void relink_to_local(snd_pcm_substream_t *substream) +static void relink_to_local(struct snd_pcm_substream *substream) { substream->group = &substream->self_group; INIT_LIST_HEAD(&substream->self_group.substreams); list_add_tail(&substream->link_list, &substream->self_group.substreams); } -static int snd_pcm_unlink(snd_pcm_substream_t *substream) +static int snd_pcm_unlink(struct snd_pcm_substream *substream) { struct list_head *pos; int res = 0; @@ -1629,51 +1651,51 @@ static int snd_pcm_unlink(snd_pcm_substream_t *substream) /* * hw configurator */ -static int snd_pcm_hw_rule_mul(snd_pcm_hw_params_t *params, - snd_pcm_hw_rule_t *rule) +static int snd_pcm_hw_rule_mul(struct snd_pcm_hw_params *params, + struct snd_pcm_hw_rule *rule) { - snd_interval_t t; + struct snd_interval t; snd_interval_mul(hw_param_interval_c(params, rule->deps[0]), hw_param_interval_c(params, rule->deps[1]), &t); return snd_interval_refine(hw_param_interval(params, rule->var), &t); } -static int snd_pcm_hw_rule_div(snd_pcm_hw_params_t *params, - snd_pcm_hw_rule_t *rule) +static int snd_pcm_hw_rule_div(struct snd_pcm_hw_params *params, + struct snd_pcm_hw_rule *rule) { - snd_interval_t t; + struct snd_interval t; snd_interval_div(hw_param_interval_c(params, rule->deps[0]), hw_param_interval_c(params, rule->deps[1]), &t); return snd_interval_refine(hw_param_interval(params, rule->var), &t); } -static int snd_pcm_hw_rule_muldivk(snd_pcm_hw_params_t *params, - snd_pcm_hw_rule_t *rule) +static int snd_pcm_hw_rule_muldivk(struct snd_pcm_hw_params *params, + struct snd_pcm_hw_rule *rule) { - snd_interval_t t; + struct snd_interval t; snd_interval_muldivk(hw_param_interval_c(params, rule->deps[0]), hw_param_interval_c(params, rule->deps[1]), (unsigned long) rule->private, &t); return snd_interval_refine(hw_param_interval(params, rule->var), &t); } -static int snd_pcm_hw_rule_mulkdiv(snd_pcm_hw_params_t *params, - snd_pcm_hw_rule_t *rule) +static int snd_pcm_hw_rule_mulkdiv(struct snd_pcm_hw_params *params, + struct snd_pcm_hw_rule *rule) { - snd_interval_t t; + struct snd_interval t; snd_interval_mulkdiv(hw_param_interval_c(params, rule->deps[0]), (unsigned long) rule->private, hw_param_interval_c(params, rule->deps[1]), &t); return snd_interval_refine(hw_param_interval(params, rule->var), &t); } -static int snd_pcm_hw_rule_format(snd_pcm_hw_params_t *params, - snd_pcm_hw_rule_t *rule) +static int snd_pcm_hw_rule_format(struct snd_pcm_hw_params *params, + struct snd_pcm_hw_rule *rule) { unsigned int k; - snd_interval_t *i = hw_param_interval(params, rule->deps[0]); - snd_mask_t m; - snd_mask_t *mask = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT); + struct snd_interval *i = hw_param_interval(params, rule->deps[0]); + struct snd_mask m; + struct snd_mask *mask = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT); snd_mask_any(&m); for (k = 0; k <= SNDRV_PCM_FORMAT_LAST; ++k) { int bits; @@ -1688,10 +1710,10 @@ static int snd_pcm_hw_rule_format(snd_pcm_hw_params_t *params, return snd_mask_refine(mask, &m); } -static int snd_pcm_hw_rule_sample_bits(snd_pcm_hw_params_t *params, - snd_pcm_hw_rule_t *rule) +static int snd_pcm_hw_rule_sample_bits(struct snd_pcm_hw_params *params, + struct snd_pcm_hw_rule *rule) { - snd_interval_t t; + struct snd_interval t; unsigned int k; t.min = UINT_MAX; t.max = 0; @@ -1720,19 +1742,19 @@ static int snd_pcm_hw_rule_sample_bits(snd_pcm_hw_params_t *params, static unsigned int rates[] = { 5512, 8000, 11025, 16000, 22050, 32000, 44100, 48000, 64000, 88200, 96000, 176400, 192000 }; -static int snd_pcm_hw_rule_rate(snd_pcm_hw_params_t *params, - snd_pcm_hw_rule_t *rule) +static int snd_pcm_hw_rule_rate(struct snd_pcm_hw_params *params, + struct snd_pcm_hw_rule *rule) { - snd_pcm_hardware_t *hw = rule->private; + struct snd_pcm_hardware *hw = rule->private; return snd_interval_list(hw_param_interval(params, rule->var), ARRAY_SIZE(rates), rates, hw->rates); } -static int snd_pcm_hw_rule_buffer_bytes_max(snd_pcm_hw_params_t *params, - snd_pcm_hw_rule_t *rule) +static int snd_pcm_hw_rule_buffer_bytes_max(struct snd_pcm_hw_params *params, + struct snd_pcm_hw_rule *rule) { - snd_interval_t t; - snd_pcm_substream_t *substream = rule->private; + struct snd_interval t; + struct snd_pcm_substream *substream = rule->private; t.min = 0; t.max = substream->buffer_bytes_max; t.openmin = 0; @@ -1741,10 +1763,10 @@ static int snd_pcm_hw_rule_buffer_bytes_max(snd_pcm_hw_params_t *params, return snd_interval_refine(hw_param_interval(params, rule->var), &t); } -int snd_pcm_hw_constraints_init(snd_pcm_substream_t *substream) +int snd_pcm_hw_constraints_init(struct snd_pcm_substream *substream) { - snd_pcm_runtime_t *runtime = substream->runtime; - snd_pcm_hw_constraints_t *constrs = &runtime->hw_constraints; + struct snd_pcm_runtime *runtime = substream->runtime; + struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints; int k, err; for (k = SNDRV_PCM_HW_PARAM_FIRST_MASK; k <= SNDRV_PCM_HW_PARAM_LAST_MASK; k++) { @@ -1865,10 +1887,10 @@ int snd_pcm_hw_constraints_init(snd_pcm_substream_t *substream) return 0; } -int snd_pcm_hw_constraints_complete(snd_pcm_substream_t *substream) +int snd_pcm_hw_constraints_complete(struct snd_pcm_substream *substream) { - snd_pcm_runtime_t *runtime = substream->runtime; - snd_pcm_hardware_t *hw = &runtime->hw; + struct snd_pcm_runtime *runtime = substream->runtime; + struct snd_pcm_hardware *hw = &runtime->hw; int err; unsigned int mask = 0; @@ -1941,17 +1963,17 @@ int snd_pcm_hw_constraints_complete(snd_pcm_substream_t *substream) return 0; } -static void snd_pcm_add_file(snd_pcm_str_t *str, - snd_pcm_file_t *pcm_file) +static void snd_pcm_add_file(struct snd_pcm_str *str, + struct snd_pcm_file *pcm_file) { pcm_file->next = str->files; str->files = pcm_file; } -static void snd_pcm_remove_file(snd_pcm_str_t *str, - snd_pcm_file_t *pcm_file) +static void snd_pcm_remove_file(struct snd_pcm_str *str, + struct snd_pcm_file *pcm_file) { - snd_pcm_file_t * pcm_file1; + struct snd_pcm_file * pcm_file1; if (str->files == pcm_file) { str->files = pcm_file->next; } else { @@ -1963,11 +1985,11 @@ static void snd_pcm_remove_file(snd_pcm_str_t *str, } } -static int snd_pcm_release_file(snd_pcm_file_t * pcm_file) +static int snd_pcm_release_file(struct snd_pcm_file * pcm_file) { - snd_pcm_substream_t *substream; - snd_pcm_runtime_t *runtime; - snd_pcm_str_t * str; + struct snd_pcm_substream *substream; + struct snd_pcm_runtime *runtime; + struct snd_pcm_str * str; snd_assert(pcm_file != NULL, return -ENXIO); substream = pcm_file->substream; @@ -1988,14 +2010,14 @@ static int snd_pcm_release_file(snd_pcm_file_t * pcm_file) } static int snd_pcm_open_file(struct file *file, - snd_pcm_t *pcm, + struct snd_pcm *pcm, int stream, - snd_pcm_file_t **rpcm_file) + struct snd_pcm_file **rpcm_file) { int err = 0; - snd_pcm_file_t *pcm_file; - snd_pcm_substream_t *substream; - snd_pcm_str_t *str; + struct snd_pcm_file *pcm_file; + struct snd_pcm_substream *substream; + struct snd_pcm_str *str; snd_assert(rpcm_file != NULL, return -EINVAL); *rpcm_file = NULL; @@ -2048,8 +2070,8 @@ static int snd_pcm_open(struct inode *inode, struct file *file) int cardnum = SNDRV_MINOR_CARD(iminor(inode)); int device = SNDRV_MINOR_DEVICE(iminor(inode)); int err; - snd_pcm_t *pcm; - snd_pcm_file_t *pcm_file; + struct snd_pcm *pcm; + struct snd_pcm_file *pcm_file; wait_queue_t wait; if (device < SNDRV_MINOR_PCM_PLAYBACK || device >= SNDRV_MINOR_DEVICES) @@ -2105,9 +2127,9 @@ static int snd_pcm_open(struct inode *inode, struct file *file) static int snd_pcm_release(struct inode *inode, struct file *file) { - snd_pcm_t *pcm; - snd_pcm_substream_t *substream; - snd_pcm_file_t *pcm_file; + struct snd_pcm *pcm; + struct snd_pcm_substream *substream; + struct snd_pcm_file *pcm_file; pcm_file = file->private_data; substream = pcm_file->substream; @@ -2125,9 +2147,10 @@ static int snd_pcm_release(struct inode *inode, struct file *file) return 0; } -static snd_pcm_sframes_t snd_pcm_playback_rewind(snd_pcm_substream_t *substream, snd_pcm_uframes_t frames) +static snd_pcm_sframes_t snd_pcm_playback_rewind(struct snd_pcm_substream *substream, + snd_pcm_uframes_t frames) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; snd_pcm_sframes_t appl_ptr; snd_pcm_sframes_t ret; snd_pcm_sframes_t hw_avail; @@ -2174,9 +2197,10 @@ static snd_pcm_sframes_t snd_pcm_playback_rewind(snd_pcm_substream_t *substream, return ret; } -static snd_pcm_sframes_t snd_pcm_capture_rewind(snd_pcm_substream_t *substream, snd_pcm_uframes_t frames) +static snd_pcm_sframes_t snd_pcm_capture_rewind(struct snd_pcm_substream *substream, + snd_pcm_uframes_t frames) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; snd_pcm_sframes_t appl_ptr; snd_pcm_sframes_t ret; snd_pcm_sframes_t hw_avail; @@ -2223,9 +2247,10 @@ static snd_pcm_sframes_t snd_pcm_capture_rewind(snd_pcm_substream_t *substream, return ret; } -static snd_pcm_sframes_t snd_pcm_playback_forward(snd_pcm_substream_t *substream, snd_pcm_uframes_t frames) +static snd_pcm_sframes_t snd_pcm_playback_forward(struct snd_pcm_substream *substream, + snd_pcm_uframes_t frames) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; snd_pcm_sframes_t appl_ptr; snd_pcm_sframes_t ret; snd_pcm_sframes_t avail; @@ -2273,9 +2298,10 @@ static snd_pcm_sframes_t snd_pcm_playback_forward(snd_pcm_substream_t *substream return ret; } -static snd_pcm_sframes_t snd_pcm_capture_forward(snd_pcm_substream_t *substream, snd_pcm_uframes_t frames) +static snd_pcm_sframes_t snd_pcm_capture_forward(struct snd_pcm_substream *substream, + snd_pcm_uframes_t frames) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; snd_pcm_sframes_t appl_ptr; snd_pcm_sframes_t ret; snd_pcm_sframes_t avail; @@ -2323,9 +2349,9 @@ static snd_pcm_sframes_t snd_pcm_capture_forward(snd_pcm_substream_t *substream, return ret; } -static int snd_pcm_hwsync(snd_pcm_substream_t *substream) +static int snd_pcm_hwsync(struct snd_pcm_substream *substream) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; int err; snd_pcm_stream_lock_irq(substream); @@ -2353,9 +2379,10 @@ static int snd_pcm_hwsync(snd_pcm_substream_t *substream) return err; } -static int snd_pcm_delay(snd_pcm_substream_t *substream, snd_pcm_sframes_t __user *res) +static int snd_pcm_delay(struct snd_pcm_substream *substream, + snd_pcm_sframes_t __user *res) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; int err; snd_pcm_sframes_t n = 0; @@ -2391,18 +2418,19 @@ static int snd_pcm_delay(snd_pcm_substream_t *substream, snd_pcm_sframes_t __use return err; } -static int snd_pcm_sync_ptr(snd_pcm_substream_t *substream, struct sndrv_pcm_sync_ptr __user *_sync_ptr) +static int snd_pcm_sync_ptr(struct snd_pcm_substream *substream, + struct snd_pcm_sync_ptr __user *_sync_ptr) { - snd_pcm_runtime_t *runtime = substream->runtime; - struct sndrv_pcm_sync_ptr sync_ptr; - volatile struct sndrv_pcm_mmap_status *status; - volatile struct sndrv_pcm_mmap_control *control; + struct snd_pcm_runtime *runtime = substream->runtime; + struct snd_pcm_sync_ptr sync_ptr; + volatile struct snd_pcm_mmap_status *status; + volatile struct snd_pcm_mmap_control *control; int err; memset(&sync_ptr, 0, sizeof(sync_ptr)); if (get_user(sync_ptr.flags, (unsigned __user *)&(_sync_ptr->flags))) return -EFAULT; - if (copy_from_user(&sync_ptr.c.control, &(_sync_ptr->c.control), sizeof(struct sndrv_pcm_mmap_control))) + if (copy_from_user(&sync_ptr.c.control, &(_sync_ptr->c.control), sizeof(struct snd_pcm_mmap_control))) return -EFAULT; status = runtime->status; control = runtime->control; @@ -2430,12 +2458,12 @@ static int snd_pcm_sync_ptr(snd_pcm_substream_t *substream, struct sndrv_pcm_syn return 0; } -static int snd_pcm_playback_ioctl1(snd_pcm_substream_t *substream, +static int snd_pcm_playback_ioctl1(struct snd_pcm_substream *substream, unsigned int cmd, void __user *arg); -static int snd_pcm_capture_ioctl1(snd_pcm_substream_t *substream, +static int snd_pcm_capture_ioctl1(struct snd_pcm_substream *substream, unsigned int cmd, void __user *arg); -static int snd_pcm_common_ioctl1(snd_pcm_substream_t *substream, +static int snd_pcm_common_ioctl1(struct snd_pcm_substream *substream, unsigned int cmd, void __user *arg) { snd_assert(substream != NULL, return -ENXIO); @@ -2492,7 +2520,7 @@ static int snd_pcm_common_ioctl1(snd_pcm_substream_t *substream, return -ENOTTY; } -static int snd_pcm_playback_ioctl1(snd_pcm_substream_t *substream, +static int snd_pcm_playback_ioctl1(struct snd_pcm_substream *substream, unsigned int cmd, void __user *arg) { snd_assert(substream != NULL, return -ENXIO); @@ -2500,9 +2528,9 @@ static int snd_pcm_playback_ioctl1(snd_pcm_substream_t *substream, switch (cmd) { case SNDRV_PCM_IOCTL_WRITEI_FRAMES: { - snd_xferi_t xferi; - snd_xferi_t __user *_xferi = arg; - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_xferi xferi; + struct snd_xferi __user *_xferi = arg; + struct snd_pcm_runtime *runtime = substream->runtime; snd_pcm_sframes_t result; if (runtime->status->state == SNDRV_PCM_STATE_OPEN) return -EBADFD; @@ -2516,9 +2544,9 @@ static int snd_pcm_playback_ioctl1(snd_pcm_substream_t *substream, } case SNDRV_PCM_IOCTL_WRITEN_FRAMES: { - snd_xfern_t xfern; - snd_xfern_t __user *_xfern = arg; - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_xfern xfern; + struct snd_xfern __user *_xfern = arg; + struct snd_pcm_runtime *runtime = substream->runtime; void __user **bufs; snd_pcm_sframes_t result; if (runtime->status->state == SNDRV_PCM_STATE_OPEN) @@ -2579,7 +2607,7 @@ static int snd_pcm_playback_ioctl1(snd_pcm_substream_t *substream, return snd_pcm_common_ioctl1(substream, cmd, arg); } -static int snd_pcm_capture_ioctl1(snd_pcm_substream_t *substream, +static int snd_pcm_capture_ioctl1(struct snd_pcm_substream *substream, unsigned int cmd, void __user *arg) { snd_assert(substream != NULL, return -ENXIO); @@ -2587,9 +2615,9 @@ static int snd_pcm_capture_ioctl1(snd_pcm_substream_t *substream, switch (cmd) { case SNDRV_PCM_IOCTL_READI_FRAMES: { - snd_xferi_t xferi; - snd_xferi_t __user *_xferi = arg; - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_xferi xferi; + struct snd_xferi __user *_xferi = arg; + struct snd_pcm_runtime *runtime = substream->runtime; snd_pcm_sframes_t result; if (runtime->status->state == SNDRV_PCM_STATE_OPEN) return -EBADFD; @@ -2603,9 +2631,9 @@ static int snd_pcm_capture_ioctl1(snd_pcm_substream_t *substream, } case SNDRV_PCM_IOCTL_READN_FRAMES: { - snd_xfern_t xfern; - snd_xfern_t __user *_xfern = arg; - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_xfern xfern; + struct snd_xfern __user *_xfern = arg; + struct snd_pcm_runtime *runtime = substream->runtime; void *bufs; snd_pcm_sframes_t result; if (runtime->status->state == SNDRV_PCM_STATE_OPEN) @@ -2658,9 +2686,10 @@ static int snd_pcm_capture_ioctl1(snd_pcm_substream_t *substream, return snd_pcm_common_ioctl1(substream, cmd, arg); } -static long snd_pcm_playback_ioctl(struct file *file, unsigned int cmd, unsigned long arg) +static long snd_pcm_playback_ioctl(struct file *file, unsigned int cmd, + unsigned long arg) { - snd_pcm_file_t *pcm_file; + struct snd_pcm_file *pcm_file; pcm_file = file->private_data; @@ -2670,9 +2699,10 @@ static long snd_pcm_playback_ioctl(struct file *file, unsigned int cmd, unsigned return snd_pcm_playback_ioctl1(pcm_file->substream, cmd, (void __user *)arg); } -static long snd_pcm_capture_ioctl(struct file *file, unsigned int cmd, unsigned long arg) +static long snd_pcm_capture_ioctl(struct file *file, unsigned int cmd, + unsigned long arg) { - snd_pcm_file_t *pcm_file; + struct snd_pcm_file *pcm_file; pcm_file = file->private_data; @@ -2682,7 +2712,7 @@ static long snd_pcm_capture_ioctl(struct file *file, unsigned int cmd, unsigned return snd_pcm_capture_ioctl1(pcm_file->substream, cmd, (void __user *)arg); } -int snd_pcm_kernel_playback_ioctl(snd_pcm_substream_t *substream, +int snd_pcm_kernel_playback_ioctl(struct snd_pcm_substream *substream, unsigned int cmd, void *arg) { mm_segment_t fs; @@ -2694,7 +2724,7 @@ int snd_pcm_kernel_playback_ioctl(snd_pcm_substream_t *substream, return result; } -int snd_pcm_kernel_capture_ioctl(snd_pcm_substream_t *substream, +int snd_pcm_kernel_capture_ioctl(struct snd_pcm_substream *substream, unsigned int cmd, void *arg) { mm_segment_t fs; @@ -2706,7 +2736,7 @@ int snd_pcm_kernel_capture_ioctl(snd_pcm_substream_t *substream, return result; } -int snd_pcm_kernel_ioctl(snd_pcm_substream_t *substream, +int snd_pcm_kernel_ioctl(struct snd_pcm_substream *substream, unsigned int cmd, void *arg) { switch (substream->stream) { @@ -2719,11 +2749,12 @@ int snd_pcm_kernel_ioctl(snd_pcm_substream_t *substream, } } -static ssize_t snd_pcm_read(struct file *file, char __user *buf, size_t count, loff_t * offset) +static ssize_t snd_pcm_read(struct file *file, char __user *buf, size_t count, + loff_t * offset) { - snd_pcm_file_t *pcm_file; - snd_pcm_substream_t *substream; - snd_pcm_runtime_t *runtime; + struct snd_pcm_file *pcm_file; + struct snd_pcm_substream *substream; + struct snd_pcm_runtime *runtime; snd_pcm_sframes_t result; pcm_file = file->private_data; @@ -2741,11 +2772,12 @@ static ssize_t snd_pcm_read(struct file *file, char __user *buf, size_t count, l return result; } -static ssize_t snd_pcm_write(struct file *file, const char __user *buf, size_t count, loff_t * offset) +static ssize_t snd_pcm_write(struct file *file, const char __user *buf, + size_t count, loff_t * offset) { - snd_pcm_file_t *pcm_file; - snd_pcm_substream_t *substream; - snd_pcm_runtime_t *runtime; + struct snd_pcm_file *pcm_file; + struct snd_pcm_substream *substream; + struct snd_pcm_runtime *runtime; snd_pcm_sframes_t result; pcm_file = file->private_data; @@ -2772,9 +2804,9 @@ static ssize_t snd_pcm_readv(struct file *file, const struct iovec *_vector, unsigned long count, loff_t * offset) { - snd_pcm_file_t *pcm_file; - snd_pcm_substream_t *substream; - snd_pcm_runtime_t *runtime; + struct snd_pcm_file *pcm_file; + struct snd_pcm_substream *substream; + struct snd_pcm_runtime *runtime; snd_pcm_sframes_t result; unsigned long i; void __user **bufs; @@ -2806,9 +2838,9 @@ static ssize_t snd_pcm_readv(struct file *file, const struct iovec *_vector, static ssize_t snd_pcm_writev(struct file *file, const struct iovec *_vector, unsigned long count, loff_t * offset) { - snd_pcm_file_t *pcm_file; - snd_pcm_substream_t *substream; - snd_pcm_runtime_t *runtime; + struct snd_pcm_file *pcm_file; + struct snd_pcm_substream *substream; + struct snd_pcm_runtime *runtime; snd_pcm_sframes_t result; unsigned long i; void __user **bufs; @@ -2843,9 +2875,9 @@ static ssize_t snd_pcm_writev(struct file *file, const struct iovec *_vector, static unsigned int snd_pcm_playback_poll(struct file *file, poll_table * wait) { - snd_pcm_file_t *pcm_file; - snd_pcm_substream_t *substream; - snd_pcm_runtime_t *runtime; + struct snd_pcm_file *pcm_file; + struct snd_pcm_substream *substream; + struct snd_pcm_runtime *runtime; unsigned int mask; snd_pcm_uframes_t avail; @@ -2881,9 +2913,9 @@ static unsigned int snd_pcm_playback_poll(struct file *file, poll_table * wait) static unsigned int snd_pcm_capture_poll(struct file *file, poll_table * wait) { - snd_pcm_file_t *pcm_file; - snd_pcm_substream_t *substream; - snd_pcm_runtime_t *runtime; + struct snd_pcm_file *pcm_file; + struct snd_pcm_substream *substream; + struct snd_pcm_runtime *runtime; unsigned int mask; snd_pcm_uframes_t avail; @@ -2933,10 +2965,11 @@ static unsigned int snd_pcm_capture_poll(struct file *file, poll_table * wait) /* * mmap status record */ -static struct page * snd_pcm_mmap_status_nopage(struct vm_area_struct *area, unsigned long address, int *type) +static struct page * snd_pcm_mmap_status_nopage(struct vm_area_struct *area, + unsigned long address, int *type) { - snd_pcm_substream_t *substream = (snd_pcm_substream_t *)area->vm_private_data; - snd_pcm_runtime_t *runtime; + struct snd_pcm_substream *substream = area->vm_private_data; + struct snd_pcm_runtime *runtime; struct page * page; if (substream == NULL) @@ -2954,17 +2987,17 @@ static struct vm_operations_struct snd_pcm_vm_ops_status = .nopage = snd_pcm_mmap_status_nopage, }; -static int snd_pcm_mmap_status(snd_pcm_substream_t *substream, struct file *file, +static int snd_pcm_mmap_status(struct snd_pcm_substream *substream, struct file *file, struct vm_area_struct *area) { - snd_pcm_runtime_t *runtime; + struct snd_pcm_runtime *runtime; long size; if (!(area->vm_flags & VM_READ)) return -EINVAL; runtime = substream->runtime; snd_assert(runtime != NULL, return -EAGAIN); size = area->vm_end - area->vm_start; - if (size != PAGE_ALIGN(sizeof(snd_pcm_mmap_status_t))) + if (size != PAGE_ALIGN(sizeof(struct snd_pcm_mmap_status))) return -EINVAL; area->vm_ops = &snd_pcm_vm_ops_status; area->vm_private_data = substream; @@ -2975,10 +3008,11 @@ static int snd_pcm_mmap_status(snd_pcm_substream_t *substream, struct file *file /* * mmap control record */ -static struct page * snd_pcm_mmap_control_nopage(struct vm_area_struct *area, unsigned long address, int *type) +static struct page * snd_pcm_mmap_control_nopage(struct vm_area_struct *area, + unsigned long address, int *type) { - snd_pcm_substream_t *substream = (snd_pcm_substream_t *)area->vm_private_data; - snd_pcm_runtime_t *runtime; + struct snd_pcm_substream *substream = area->vm_private_data; + struct snd_pcm_runtime *runtime; struct page * page; if (substream == NULL) @@ -2996,17 +3030,17 @@ static struct vm_operations_struct snd_pcm_vm_ops_control = .nopage = snd_pcm_mmap_control_nopage, }; -static int snd_pcm_mmap_control(snd_pcm_substream_t *substream, struct file *file, +static int snd_pcm_mmap_control(struct snd_pcm_substream *substream, struct file *file, struct vm_area_struct *area) { - snd_pcm_runtime_t *runtime; + struct snd_pcm_runtime *runtime; long size; if (!(area->vm_flags & VM_READ)) return -EINVAL; runtime = substream->runtime; snd_assert(runtime != NULL, return -EAGAIN); size = area->vm_end - area->vm_start; - if (size != PAGE_ALIGN(sizeof(snd_pcm_mmap_control_t))) + if (size != PAGE_ALIGN(sizeof(struct snd_pcm_mmap_control))) return -EINVAL; area->vm_ops = &snd_pcm_vm_ops_control; area->vm_private_data = substream; @@ -3017,12 +3051,12 @@ static int snd_pcm_mmap_control(snd_pcm_substream_t *substream, struct file *fil /* * don't support mmap for status and control records. */ -static int snd_pcm_mmap_status(snd_pcm_substream_t *substream, struct file *file, +static int snd_pcm_mmap_status(struct snd_pcm_substream *substream, struct file *file, struct vm_area_struct *area) { return -ENXIO; } -static int snd_pcm_mmap_control(snd_pcm_substream_t *substream, struct file *file, +static int snd_pcm_mmap_control(struct snd_pcm_substream *substream, struct file *file, struct vm_area_struct *area) { return -ENXIO; @@ -3032,10 +3066,11 @@ static int snd_pcm_mmap_control(snd_pcm_substream_t *substream, struct file *fil /* * nopage callback for mmapping a RAM page */ -static struct page *snd_pcm_mmap_data_nopage(struct vm_area_struct *area, unsigned long address, int *type) +static struct page *snd_pcm_mmap_data_nopage(struct vm_area_struct *area, + unsigned long address, int *type) { - snd_pcm_substream_t *substream = (snd_pcm_substream_t *)area->vm_private_data; - snd_pcm_runtime_t *runtime; + struct snd_pcm_substream *substream = area->vm_private_data; + struct snd_pcm_runtime *runtime; unsigned long offset; struct page * page; void *vaddr; @@ -3074,7 +3109,8 @@ static struct vm_operations_struct snd_pcm_vm_ops_data = /* * mmap the DMA buffer on RAM */ -static int snd_pcm_default_mmap(snd_pcm_substream_t *substream, struct vm_area_struct *area) +static int snd_pcm_default_mmap(struct snd_pcm_substream *substream, + struct vm_area_struct *area) { area->vm_ops = &snd_pcm_vm_ops_data; area->vm_private_data = substream; @@ -3093,7 +3129,8 @@ static struct vm_operations_struct snd_pcm_vm_ops_data_mmio = .close = snd_pcm_mmap_data_close, }; -int snd_pcm_lib_mmap_iomem(snd_pcm_substream_t *substream, struct vm_area_struct *area) +int snd_pcm_lib_mmap_iomem(struct snd_pcm_substream *substream, + struct vm_area_struct *area) { long size; unsigned long offset; @@ -3118,10 +3155,10 @@ int snd_pcm_lib_mmap_iomem(snd_pcm_substream_t *substream, struct vm_area_struct /* * mmap DMA buffer */ -int snd_pcm_mmap_data(snd_pcm_substream_t *substream, struct file *file, +int snd_pcm_mmap_data(struct snd_pcm_substream *substream, struct file *file, struct vm_area_struct *area) { - snd_pcm_runtime_t *runtime; + struct snd_pcm_runtime *runtime; long size; unsigned long offset; size_t dma_bytes; @@ -3158,8 +3195,8 @@ int snd_pcm_mmap_data(snd_pcm_substream_t *substream, struct file *file, static int snd_pcm_mmap(struct file *file, struct vm_area_struct *area) { - snd_pcm_file_t * pcm_file; - snd_pcm_substream_t *substream; + struct snd_pcm_file * pcm_file; + struct snd_pcm_substream *substream; unsigned long offset; pcm_file = file->private_data; @@ -3184,9 +3221,9 @@ static int snd_pcm_mmap(struct file *file, struct vm_area_struct *area) static int snd_pcm_fasync(int fd, struct file * file, int on) { - snd_pcm_file_t * pcm_file; - snd_pcm_substream_t *substream; - snd_pcm_runtime_t *runtime; + struct snd_pcm_file * pcm_file; + struct snd_pcm_substream *substream; + struct snd_pcm_runtime *runtime; int err; pcm_file = file->private_data; @@ -3216,7 +3253,8 @@ static int snd_pcm_fasync(int fd, struct file * file, int on) #define __OLD_TO_NEW_MASK(x) ((x&7)|((x&0x07fffff8)<<5)) #define __NEW_TO_OLD_MASK(x) ((x&7)|((x&0xffffff00)>>5)) -static void snd_pcm_hw_convert_from_old_params(snd_pcm_hw_params_t *params, struct sndrv_pcm_hw_params_old *oparams) +static void snd_pcm_hw_convert_from_old_params(struct snd_pcm_hw_params *params, + struct snd_pcm_hw_params_old *oparams) { unsigned int i; @@ -3234,7 +3272,8 @@ static void snd_pcm_hw_convert_from_old_params(snd_pcm_hw_params_t *params, stru params->fifo_size = oparams->fifo_size; } -static void snd_pcm_hw_convert_to_old_params(struct sndrv_pcm_hw_params_old *oparams, snd_pcm_hw_params_t *params) +static void snd_pcm_hw_convert_to_old_params(struct snd_pcm_hw_params_old *oparams, + struct snd_pcm_hw_params *params) { unsigned int i; @@ -3252,10 +3291,11 @@ static void snd_pcm_hw_convert_to_old_params(struct sndrv_pcm_hw_params_old *opa oparams->fifo_size = params->fifo_size; } -static int snd_pcm_hw_refine_old_user(snd_pcm_substream_t * substream, struct sndrv_pcm_hw_params_old __user * _oparams) +static int snd_pcm_hw_refine_old_user(struct snd_pcm_substream *substream, + struct snd_pcm_hw_params_old __user * _oparams) { - snd_pcm_hw_params_t *params; - struct sndrv_pcm_hw_params_old *oparams = NULL; + struct snd_pcm_hw_params *params; + struct snd_pcm_hw_params_old *oparams = NULL; int err; params = kmalloc(sizeof(*params), GFP_KERNEL); @@ -3286,10 +3326,11 @@ out: return err; } -static int snd_pcm_hw_params_old_user(snd_pcm_substream_t * substream, struct sndrv_pcm_hw_params_old __user * _oparams) +static int snd_pcm_hw_params_old_user(struct snd_pcm_substream *substream, + struct snd_pcm_hw_params_old __user * _oparams) { - snd_pcm_hw_params_t *params; - struct sndrv_pcm_hw_params_old *oparams = NULL; + struct snd_pcm_hw_params *params; + struct snd_pcm_hw_params_old *oparams = NULL; int err; params = kmalloc(sizeof(*params), GFP_KERNEL); @@ -3349,7 +3390,7 @@ static struct file_operations snd_pcm_f_ops_capture = { .fasync = snd_pcm_fasync, }; -snd_minor_t snd_pcm_reg[2] = +struct snd_minor snd_pcm_reg[2] = { { .comment = "digital audio playback", diff --git a/sound/core/pcm_timer.c b/sound/core/pcm_timer.c index 884eaea31fec..d94ed16d21ea 100644 --- a/sound/core/pcm_timer.c +++ b/sound/core/pcm_timer.c @@ -45,10 +45,10 @@ static unsigned long gcd(unsigned long a, unsigned long 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; - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; mult = 1000000000; rate = runtime->rate; @@ -74,18 +74,18 @@ void snd_pcm_timer_resolution_change(snd_pcm_substream_t *substream) 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; 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; - snd_pcm_substream_t * substream; + struct snd_pcm_substream *substream; substream = snd_timer_chip(timer); spin_lock_irqsave(&substream->timer_lock, flags); @@ -94,10 +94,10 @@ static int snd_pcm_timer_start(snd_timer_t * timer) 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; - snd_pcm_substream_t * substream; + struct snd_pcm_substream *substream; substream = snd_timer_chip(timer); spin_lock_irqsave(&substream->timer_lock, flags); @@ -106,7 +106,7 @@ static int snd_pcm_timer_stop(snd_timer_t * timer) 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, .resolution = 0, @@ -120,16 +120,16 @@ static struct _snd_timer_hardware snd_pcm_timer = * 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; } -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; - snd_timer_t *timer; + struct snd_timer_id tid; + struct snd_timer *timer; tid.dev_sclass = SNDRV_TIMER_SCLASS_NONE; tid.dev_class = SNDRV_TIMER_CLASS_PCM; @@ -152,7 +152,7 @@ void snd_pcm_timer_init(snd_pcm_substream_t *substream) 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) { snd_device_free(substream->pcm->card, substream->timer); -- 2.30.2