mirror of
https://github.com/torvalds/linux
synced 2024-09-06 18:01:05 +00:00
[ALSA] Remove xxx_t typedefs: PCM
Modules: PCM Midlevel Remove xxx_t typedefs from the core PCM codes. Signed-off-by: Takashi Iwai <tiwai@suse.de>
This commit is contained in:
parent
24c1f93188
commit
877211f5e1
|
@ -24,7 +24,7 @@
|
|||
|
||||
#include <sound/pcm.h>
|
||||
|
||||
typedef struct sndrv_pcm_indirect {
|
||||
struct snd_pcm_indirect {
|
||||
unsigned int hw_buffer_size; /* Byte size of hardware buffer */
|
||||
unsigned int hw_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;
|
||||
|
|
|
@ -28,36 +28,9 @@
|
|||
#include <linux/poll.h>
|
||||
#include <linux/bitops.h>
|
||||
|
||||
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
|
||||
|
|
|
@ -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;
|
||||
|
|
214
sound/core/pcm.c
214
sound/core/pcm.c
|
@ -33,18 +33,18 @@ MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>, Abramo Bagnara <abramo@alsa-proj
|
|||
MODULE_DESCRIPTION("Midlevel PCM code for ALSA.");
|
||||
MODULE_LICENSE("GPL");
|
||||
|
||||
snd_pcm_t *snd_pcm_devices[SNDRV_CARDS * SNDRV_PCM_DEVICES];
|
||||
struct snd_pcm *snd_pcm_devices[SNDRV_CARDS * SNDRV_PCM_DEVICES];
|
||||
static LIST_HEAD(snd_pcm_notify_list);
|
||||
static DECLARE_MUTEX(register_mutex);
|
||||
|
||||
static int snd_pcm_free(snd_pcm_t *pcm);
|
||||
static int snd_pcm_dev_free(snd_device_t *device);
|
||||
static int snd_pcm_dev_register(snd_device_t *device);
|
||||
static int snd_pcm_dev_disconnect(snd_device_t *device);
|
||||
static int snd_pcm_dev_unregister(snd_device_t *device);
|
||||
static int snd_pcm_free(struct snd_pcm *pcm);
|
||||
static int snd_pcm_dev_free(struct snd_device *device);
|
||||
static int snd_pcm_dev_register(struct snd_device *device);
|
||||
static int snd_pcm_dev_disconnect(struct snd_device *device);
|
||||
static int snd_pcm_dev_unregister(struct snd_device *device);
|
||||
|
||||
static int snd_pcm_control_ioctl(snd_card_t * card,
|
||||
snd_ctl_file_t * control,
|
||||
static int snd_pcm_control_ioctl(struct snd_card *card,
|
||||
struct snd_ctl_file *control,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
{
|
||||
unsigned int tmp;
|
||||
|
@ -71,13 +71,13 @@ static int snd_pcm_control_ioctl(snd_card_t * card,
|
|||
}
|
||||
case SNDRV_CTL_IOCTL_PCM_INFO:
|
||||
{
|
||||
snd_pcm_info_t __user *info;
|
||||
struct snd_pcm_info __user *info;
|
||||
unsigned int device, subdevice;
|
||||
snd_pcm_stream_t stream;
|
||||
snd_pcm_t *pcm;
|
||||
snd_pcm_str_t *pstr;
|
||||
snd_pcm_substream_t *substream;
|
||||
info = (snd_pcm_info_t __user *)arg;
|
||||
int stream;
|
||||
struct snd_pcm *pcm;
|
||||
struct snd_pcm_str *pstr;
|
||||
struct snd_pcm_substream *substream;
|
||||
info = (struct snd_pcm_info __user *)arg;
|
||||
if (get_user(device, &info->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;
|
||||
|
|
|
@ -22,7 +22,7 @@
|
|||
|
||||
#include <linux/compat.h>
|
||||
|
||||
static int snd_pcm_ioctl_delay_compat(snd_pcm_substream_t *substream,
|
||||
static int snd_pcm_ioctl_delay_compat(struct snd_pcm_substream *substream,
|
||||
s32 __user *src)
|
||||
{
|
||||
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;
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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! */
|
||||
|
|
File diff suppressed because it is too large
Load diff
|
@ -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);
|
||||
|
|
Loading…
Reference in a new issue