Skip to content

cloud-kernel
cloud-kernel

openanolis / cloud-kernel
大约 1 年 前同步成功

通知 158
Star 36
Fork 7
cloud-kernel
cloud-kernel

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

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

[ALSA] Remove xxx_t typedefs: Sequencer 

Modules: ALSA sequencer

Remove xxx_t typedefs from the core sequencer codes.
Signed-off-by: NTakashi Iwai <tiwai@suse.de>
上级 6ac77bc1
展开全部 隐藏空白更改
内联 并排
Showing with 1363 addition and 1279 deletion
include/sound/asequencer.h
浏览文件 @ c7e0b5bf
此差异已折叠。
include/sound/seq_device.h
浏览文件 @ c7e0b5bf
......@@ -21,9 +21,6 @@
*
*/
typedef struct snd_seq_device snd_seq_device_t;
typedef struct snd_seq_dev_ops snd_seq_dev_ops_t;
/*
* registered device information
*/
......@@ -36,7 +33,7 @@ typedef struct snd_seq_dev_ops snd_seq_dev_ops_t;
struct snd_seq_device {
/* device info */
snd_card_t *card; /* sound card */
struct snd_card *card; /* sound card */
int device; /* device number */
char id[ID_LEN]; /* driver id */
char name[80]; /* device name */
......@@ -44,7 +41,7 @@ struct snd_seq_device {
void *driver_data; /* private data for driver */
int status; /* flag - read only */
void *private_data; /* private data for the caller */
void (*private_free)(snd_seq_device_t *device);
void (*private_free)(struct snd_seq_device *device);
struct list_head list; /* link to next device */
};
......@@ -63,19 +60,19 @@ struct snd_seq_device {
* Typically, call snd_device_free(dev->card, dev->driver_data)
*/
struct snd_seq_dev_ops {
int (*init_device)(snd_seq_device_t *dev);
int (*free_device)(snd_seq_device_t *dev);
int (*init_device)(struct snd_seq_device *dev);
int (*free_device)(struct snd_seq_device *dev);
};
/*
* prototypes
*/
void snd_seq_device_load_drivers(void);
int snd_seq_device_new(snd_card_t *card, int device, char *id, int argsize, snd_seq_device_t **result);
int snd_seq_device_register_driver(char *id, snd_seq_dev_ops_t *entry, int argsize);
int snd_seq_device_new(struct snd_card *card, int device, char *id, int argsize, struct snd_seq_device **result);
int snd_seq_device_register_driver(char *id, struct snd_seq_dev_ops *entry, int argsize);
int snd_seq_device_unregister_driver(char *id);
#define SNDRV_SEQ_DEVICE_ARGPTR(dev) (void *)((char *)(dev) + sizeof(snd_seq_device_t))
#define SNDRV_SEQ_DEVICE_ARGPTR(dev) (void *)((char *)(dev) + sizeof(struct snd_seq_device))
/*
......@@ -84,5 +81,4 @@ int snd_seq_device_unregister_driver(char *id);
#define SNDRV_SEQ_DEV_ID_MIDISYNTH "seq-midi"
#define SNDRV_SEQ_DEV_ID_OPL3 "opl3-synth"
#endif /* __SOUND_SEQ_DEVICE_H */
include/sound/seq_instr.h
浏览文件 @ c7e0b5bf
......@@ -24,29 +24,27 @@
#include "seq_kernel.h"
/* Instrument cluster */
typedef struct _snd_seq_kcluster {
struct snd_seq_kcluster {
snd_seq_instr_cluster_t cluster;
char name[32];
int priority;
struct _snd_seq_kcluster *next;
} snd_seq_kcluster_t;
struct snd_seq_kcluster *next;
};
/* return pointer to private data */
#define KINSTR_DATA(kinstr) (void *)(((char *)kinstr) + sizeof(snd_seq_kinstr_t))
typedef struct snd_seq_kinstr_ops snd_seq_kinstr_ops_t;
#define KINSTR_DATA(kinstr) (void *)(((char *)kinstr) + sizeof(struct snd_seq_kinstr))
/* Instrument structure */
typedef struct _snd_seq_kinstr {
snd_seq_instr_t instr;
struct snd_seq_kinstr {
struct snd_seq_instr instr;
char name[32];
int type; /* instrument type */
int use; /* use count */
int busy; /* not useable */
int add_len; /* additional length */
snd_seq_kinstr_ops_t *ops; /* operations */
struct _snd_seq_kinstr *next;
} snd_seq_kinstr_t;
struct snd_seq_kinstr_ops *ops; /* operations */
struct snd_seq_kinstr *next;
};
#define SNDRV_SEQ_INSTR_HASH_SIZE 32
......@@ -54,11 +52,11 @@ typedef struct _snd_seq_kinstr {
#define SNDRV_SEQ_INSTR_FLG_DIRECT (1<<0) /* accept only direct events */
/* List of all instruments */
typedef struct {
snd_seq_kinstr_t *hash[SNDRV_SEQ_INSTR_HASH_SIZE];
struct snd_seq_kinstr_list {
struct snd_seq_kinstr *hash[SNDRV_SEQ_INSTR_HASH_SIZE];
int count; /* count of all instruments */
snd_seq_kcluster_t *chash[SNDRV_SEQ_INSTR_HASH_SIZE];
struct snd_seq_kcluster *chash[SNDRV_SEQ_INSTR_HASH_SIZE];
int ccount; /* count of all clusters */
int owner; /* current owner of the instrument list */
......@@ -68,7 +66,7 @@ typedef struct {
spinlock_t ops_lock;
struct semaphore ops_mutex;
unsigned long ops_flags;
} snd_seq_kinstr_list_t;
};
#define SNDRV_SEQ_INSTR_NOTIFY_REMOVE 0
#define SNDRV_SEQ_INSTR_NOTIFY_CHANGE 1
......@@ -78,33 +76,33 @@ struct snd_seq_kinstr_ops {
long add_len; /* additional length */
char *instr_type;
int (*info)(void *private_data, char *info_data, long len);
int (*put)(void *private_data, snd_seq_kinstr_t *kinstr,
int (*put)(void *private_data, struct snd_seq_kinstr *kinstr,
char __user *instr_data, long len, int atomic, int cmd);
int (*get)(void *private_data, snd_seq_kinstr_t *kinstr,
int (*get)(void *private_data, struct snd_seq_kinstr *kinstr,
char __user *instr_data, long len, int atomic, int cmd);
int (*get_size)(void *private_data, snd_seq_kinstr_t *kinstr, long *size);
int (*remove)(void *private_data, snd_seq_kinstr_t *kinstr, int atomic);
void (*notify)(void *private_data, snd_seq_kinstr_t *kinstr, int what);
int (*get_size)(void *private_data, struct snd_seq_kinstr *kinstr, long *size);
int (*remove)(void *private_data, struct snd_seq_kinstr *kinstr, int atomic);
void (*notify)(void *private_data, struct snd_seq_kinstr *kinstr, int what);
struct snd_seq_kinstr_ops *next;
};
/* instrument operations */
snd_seq_kinstr_list_t *snd_seq_instr_list_new(void);
void snd_seq_instr_list_free(snd_seq_kinstr_list_t **list);
int snd_seq_instr_list_free_cond(snd_seq_kinstr_list_t *list,
snd_seq_instr_header_t *ifree,
struct snd_seq_kinstr_list *snd_seq_instr_list_new(void);
void snd_seq_instr_list_free(struct snd_seq_kinstr_list **list);
int snd_seq_instr_list_free_cond(struct snd_seq_kinstr_list *list,
struct snd_seq_instr_header *ifree,
int client,
int atomic);
snd_seq_kinstr_t *snd_seq_instr_find(snd_seq_kinstr_list_t *list,
snd_seq_instr_t *instr,
int exact,
int follow_alias);
void snd_seq_instr_free_use(snd_seq_kinstr_list_t *list,
snd_seq_kinstr_t *instr);
int snd_seq_instr_event(snd_seq_kinstr_ops_t *ops,
snd_seq_kinstr_list_t *list,
snd_seq_event_t *ev,
struct snd_seq_kinstr *snd_seq_instr_find(struct snd_seq_kinstr_list *list,
struct snd_seq_instr *instr,
int exact,
int follow_alias);
void snd_seq_instr_free_use(struct snd_seq_kinstr_list *list,
struct snd_seq_kinstr *instr);
int snd_seq_instr_event(struct snd_seq_kinstr_ops *ops,
struct snd_seq_kinstr_list *list,
struct snd_seq_event *ev,
int client,
int atomic,
int hop);
......
include/sound/seq_kernel.h
浏览文件 @ c7e0b5bf
......@@ -24,62 +24,8 @@
#include <linux/time.h>
#include "asequencer.h"
typedef sndrv_seq_tick_time_t snd_seq_tick_time_t;
typedef sndrv_seq_position_t snd_seq_position_t;
typedef sndrv_seq_frequency_t snd_seq_frequency_t;
typedef sndrv_seq_instr_cluster_t snd_seq_instr_cluster_t;
typedef enum sndrv_seq_client_type snd_seq_client_type_t;
typedef enum sndrv_seq_stop_mode snd_seq_stop_mode_t;
typedef struct sndrv_seq_port_info snd_seq_port_info_t;
typedef struct sndrv_seq_port_subscribe snd_seq_port_subscribe_t;
typedef struct sndrv_seq_event snd_seq_event_t;
typedef struct sndrv_seq_addr snd_seq_addr_t;
typedef struct sndrv_seq_ev_volume snd_seq_ev_volume_t;
typedef struct sndrv_seq_ev_loop snd_seq_ev_loop_t;
typedef struct sndrv_seq_remove_events snd_seq_remove_events_t;
typedef struct sndrv_seq_query_subs snd_seq_query_subs_t;
typedef struct sndrv_seq_real_time snd_seq_real_time_t;
typedef struct sndrv_seq_system_info snd_seq_system_info_t;
typedef struct sndrv_seq_client_info snd_seq_client_info_t;
typedef struct sndrv_seq_queue_info snd_seq_queue_info_t;
typedef struct sndrv_seq_queue_status snd_seq_queue_status_t;
typedef struct sndrv_seq_queue_tempo snd_seq_queue_tempo_t;
typedef struct sndrv_seq_queue_owner snd_seq_queue_owner_t;
typedef struct sndrv_seq_queue_timer snd_seq_queue_timer_t;
typedef struct sndrv_seq_queue_client snd_seq_queue_client_t;
typedef struct sndrv_seq_client_pool snd_seq_client_pool_t;
typedef struct sndrv_seq_instr snd_seq_instr_t;
typedef struct sndrv_seq_instr_data snd_seq_instr_data_t;
typedef struct sndrv_seq_instr_header snd_seq_instr_header_t;
typedef union sndrv_seq_timestamp snd_seq_timestamp_t;
#define snd_seq_event_bounce_ext_data sndrv_seq_event_bounce_ext_data
#define snd_seq_ev_is_result_type sndrv_seq_ev_is_result_type
#define snd_seq_ev_is_channel_type sndrv_seq_ev_is_channel_type
#define snd_seq_ev_is_note_type sndrv_seq_ev_is_note_type
#define snd_seq_ev_is_control_type sndrv_seq_ev_is_control_type
#define snd_seq_ev_is_queue_type sndrv_seq_ev_is_queue_type
#define snd_seq_ev_is_message_type sndrv_seq_ev_is_message_type
#define snd_seq_ev_is_sample_type sndrv_seq_ev_is_sample_type
#define snd_seq_ev_is_user_type sndrv_seq_ev_is_user_type
#define snd_seq_ev_is_fixed_type sndrv_seq_ev_is_fixed_type
#define snd_seq_ev_is_instr_type sndrv_seq_ev_is_instr_type
#define snd_seq_ev_is_variable_type sndrv_seq_ev_is_variable_type
#define snd_seq_ev_is_reserved sndrv_seq_ev_is_reserved
#define snd_seq_ev_is_direct sndrv_seq_ev_is_direct
#define snd_seq_ev_is_prior sndrv_seq_ev_is_prior
#define snd_seq_ev_length_type sndrv_seq_ev_length_type
#define snd_seq_ev_is_fixed sndrv_seq_ev_is_fixed
#define snd_seq_ev_is_variable sndrv_seq_ev_is_variable
#define snd_seq_ev_is_varusr sndrv_seq_ev_is_varusr
#define snd_seq_ev_timestamp_type sndrv_seq_ev_timestamp_type
#define snd_seq_ev_is_tick sndrv_seq_ev_is_tick
#define snd_seq_ev_is_real sndrv_seq_ev_is_real
#define snd_seq_ev_timemode_type sndrv_seq_ev_timemode_type
#define snd_seq_ev_is_abstime sndrv_seq_ev_is_abstime
#define snd_seq_ev_is_reltime sndrv_seq_ev_is_reltime
#define snd_seq_queue_sync_port sndrv_seq_queue_sync_port
#define snd_seq_queue_owner sndrv_seq_queue_owner
typedef struct snd_seq_real_time snd_seq_real_time_t;
typedef union snd_seq_timestamp snd_seq_timestamp_t;
/* maximum number of events dequeued per schedule interval */
#define SNDRV_SEQ_MAX_DEQUEUE 50
......@@ -114,69 +60,56 @@ typedef union sndrv_seq_timestamp snd_seq_timestamp_t;
/* max size of event size */
#define SNDRV_SEQ_MAX_EVENT_LEN 0x3fffffff
/* typedefs */
struct _snd_seq_user_client;
struct _snd_seq_kernel_client;
struct _snd_seq_client;
struct _snd_seq_queue;
typedef struct _snd_seq_user_client user_client_t;
typedef struct _snd_seq_kernel_client kernel_client_t;
typedef struct _snd_seq_client client_t;
typedef struct _snd_seq_queue queue_t;
/* call-backs for kernel client */
typedef struct {
struct snd_seq_client_callback {
void *private_data;
unsigned allow_input: 1,
allow_output: 1;
/*...*/
} snd_seq_client_callback_t;
};
/* call-backs for kernel port */
typedef int (snd_seq_kernel_port_open_t)(void *private_data, snd_seq_port_subscribe_t *info);
typedef int (snd_seq_kernel_port_close_t)(void *private_data, snd_seq_port_subscribe_t *info);
typedef int (snd_seq_kernel_port_input_t)(snd_seq_event_t *ev, int direct, void *private_data, int atomic, int hop);
typedef void (snd_seq_kernel_port_private_free_t)(void *private_data);
typedef struct {
struct snd_seq_port_callback {
struct module *owner;
void *private_data;
snd_seq_kernel_port_open_t *subscribe;
snd_seq_kernel_port_close_t *unsubscribe;
snd_seq_kernel_port_open_t *use;
snd_seq_kernel_port_close_t *unuse;
snd_seq_kernel_port_input_t *event_input;
snd_seq_kernel_port_private_free_t *private_free;
int (*subscribe)(void *private_data, struct snd_seq_port_subscribe *info);
int (*unsubscribe)(void *private_data, struct snd_seq_port_subscribe *info);
int (*use)(void *private_data, struct snd_seq_port_subscribe *info);
int (*unuse)(void *private_data, struct snd_seq_port_subscribe *info);
int (*event_input)(struct snd_seq_event *ev, int direct, void *private_data, int atomic, int hop);
void (*private_free)(void *private_data);
unsigned int callback_all; /* call subscribe callbacks at each connection/disconnection */
/*...*/
} snd_seq_port_callback_t;
};
/* interface for kernel client */
extern int snd_seq_create_kernel_client(snd_card_t *card, int client_index, snd_seq_client_callback_t *callback);
extern int snd_seq_delete_kernel_client(int client);
extern int snd_seq_kernel_client_enqueue(int client, snd_seq_event_t *ev, int atomic, int hop);
extern int snd_seq_kernel_client_dispatch(int client, snd_seq_event_t *ev, int atomic, int hop);
extern int snd_seq_kernel_client_ctl(int client, unsigned int cmd, void *arg);
int snd_seq_create_kernel_client(struct snd_card *card, int client_index,
struct snd_seq_client_callback *callback);
int snd_seq_delete_kernel_client(int client);
int snd_seq_kernel_client_enqueue(int client, struct snd_seq_event *ev, int atomic, int hop);
int snd_seq_kernel_client_dispatch(int client, struct snd_seq_event *ev, int atomic, int hop);
int snd_seq_kernel_client_ctl(int client, unsigned int cmd, void *arg);
#define SNDRV_SEQ_EXT_MASK 0xc0000000
#define SNDRV_SEQ_EXT_USRPTR 0x80000000
#define SNDRV_SEQ_EXT_CHAINED 0x40000000
typedef int (*snd_seq_dump_func_t)(void *ptr, void *buf, int count);
int snd_seq_expand_var_event(const snd_seq_event_t *event, int count, char *buf, int in_kernel, int size_aligned);
int snd_seq_dump_var_event(const snd_seq_event_t *event, snd_seq_dump_func_t func, void *private_data);
int snd_seq_expand_var_event(const struct snd_seq_event *event, int count, char *buf,
int in_kernel, int size_aligned);
int snd_seq_dump_var_event(const struct snd_seq_event *event,
snd_seq_dump_func_t func, void *private_data);
/* interface for OSS emulation */
int snd_seq_set_queue_tempo(int client, snd_seq_queue_tempo_t *tempo);
int snd_seq_set_queue_tempo(int client, struct snd_seq_queue_tempo *tempo);
/* port callback routines */
void snd_port_init_callback(snd_seq_port_callback_t *p);
snd_seq_port_callback_t *snd_port_alloc_callback(void);
void snd_port_init_callback(struct snd_seq_port_callback *p);
struct snd_seq_port_callback *snd_port_alloc_callback(void);
/* port attach/detach */
int snd_seq_event_port_attach(int client, snd_seq_port_callback_t *pcbp,
int snd_seq_event_port_attach(int client, struct snd_seq_port_callback *pcbp,
int cap, int type, int midi_channels, int midi_voices, char *portname);
int snd_seq_event_port_detach(int client, int port);
......
include/sound/seq_midi_emul.h
浏览文件 @ c7e0b5bf
......@@ -29,7 +29,7 @@
* channel. All drivers for hardware that does not understand midi
* directly will probably need to use this structure.
*/
typedef struct snd_midi_channel {
struct snd_midi_channel {
void *private; /* A back pointer to driver data */
int number; /* The channel number */
int client; /* The client associated with this channel */
......@@ -53,41 +53,43 @@ typedef struct snd_midi_channel {
short gm_rpn_fine_tuning; /* Master fine tuning */
short gm_rpn_coarse_tuning; /* Master coarse tuning */
} snd_midi_channel_t;
};
/*
* A structure that represets a set of channels bound to a port. There
* would usually be 16 channels per port. But fewer could be used for
* particular cases.
* The channel set consists of information describing the client and
* port for this midi synth and an array of snd_midi_channel_t structures.
* A driver that had no need for snd_midi_channel_t could still use the
* port for this midi synth and an array of snd_midi_channel structures.
* A driver that had no need for snd_midi_channel could still use the
* channel set type if it wished with the channel array null.
*/
typedef struct snd_midi_channel_set {
struct snd_midi_channel_set {
void *private_data; /* Driver data */
int client; /* Client for this port */
int port; /* The port number */
int max_channels; /* Size of the channels array */
snd_midi_channel_t *channels;
struct snd_midi_channel *channels;
unsigned char midi_mode; /* MIDI operating mode */
unsigned char gs_master_volume; /* SYSEX master volume: 0-127 */
unsigned char gs_chorus_mode;
unsigned char gs_reverb_mode;
} snd_midi_channel_set_t;
};
typedef struct snd_seq_midi_op {
void (*note_on)(void *private_data, int note, int vel, snd_midi_channel_t *chan);
void (*note_off)(void *private_data,int note, int vel, snd_midi_channel_t *chan); /* release note */
void (*key_press)(void *private_data, int note, int vel, snd_midi_channel_t *chan);
void (*note_terminate)(void *private_data, int note, snd_midi_channel_t *chan); /* terminate note immediately */
void (*control)(void *private_data, int type, snd_midi_channel_t *chan);
void (*nrpn)(void *private_data, snd_midi_channel_t *chan, snd_midi_channel_set_t *chset);
void (*sysex)(void *private_data, unsigned char *buf, int len, int parsed, snd_midi_channel_set_t *chset);
} snd_midi_op_t;
struct snd_midi_op {
void (*note_on)(void *private_data, int note, int vel, struct snd_midi_channel *chan);
void (*note_off)(void *private_data,int note, int vel, struct snd_midi_channel *chan); /* release note */
void (*key_press)(void *private_data, int note, int vel, struct snd_midi_channel *chan);
void (*note_terminate)(void *private_data, int note, struct snd_midi_channel *chan); /* terminate note immediately */
void (*control)(void *private_data, int type, struct snd_midi_channel *chan);
void (*nrpn)(void *private_data, struct snd_midi_channel *chan,
struct snd_midi_channel_set *chset);
void (*sysex)(void *private_data, unsigned char *buf, int len, int parsed,
struct snd_midi_channel_set *chset);
};
/*
* These defines are used so that pitchbend, aftertouch etc, can be
......@@ -186,10 +188,10 @@ enum {
};
/* Prototypes for midi_process.c */
void snd_midi_process_event(snd_midi_op_t *ops, snd_seq_event_t *ev,
snd_midi_channel_set_t *chanset);
void snd_midi_channel_set_clear(snd_midi_channel_set_t *chset);
snd_midi_channel_set_t *snd_midi_channel_alloc_set(int n);
void snd_midi_channel_free_set(snd_midi_channel_set_t *chset);
void snd_midi_process_event(struct snd_midi_op *ops, struct snd_seq_event *ev,
struct snd_midi_channel_set *chanset);
void snd_midi_channel_set_clear(struct snd_midi_channel_set *chset);
struct snd_midi_channel_set *snd_midi_channel_alloc_set(int n);
void snd_midi_channel_free_set(struct snd_midi_channel_set *chset);
#endif /* __SOUND_SEQ_MIDI_EMUL_H */
include/sound/seq_midi_event.h
浏览文件 @ c7e0b5bf
......@@ -26,10 +26,8 @@
#define MAX_MIDI_EVENT_BUF 256
typedef struct snd_midi_event_t snd_midi_event_t;
/* midi status */
struct snd_midi_event_t {
struct snd_midi_event {
int qlen; /* queue length */
int read; /* chars read */
int type; /* current event type */
......@@ -40,15 +38,17 @@ struct snd_midi_event_t {
spinlock_t lock;
};
int snd_midi_event_new(int bufsize, snd_midi_event_t **rdev);
void snd_midi_event_free(snd_midi_event_t *dev);
void snd_midi_event_reset_encode(snd_midi_event_t *dev);
void snd_midi_event_reset_decode(snd_midi_event_t *dev);
void snd_midi_event_no_status(snd_midi_event_t *dev, int on);
int snd_midi_event_new(int bufsize, struct snd_midi_event **rdev);
void snd_midi_event_free(struct snd_midi_event *dev);
void snd_midi_event_reset_encode(struct snd_midi_event *dev);
void snd_midi_event_reset_decode(struct snd_midi_event *dev);
void snd_midi_event_no_status(struct snd_midi_event *dev, int on);
/* encode from byte stream - return number of written bytes if success */
long snd_midi_event_encode(snd_midi_event_t *dev, unsigned char *buf, long count, snd_seq_event_t *ev);
int snd_midi_event_encode_byte(snd_midi_event_t *dev, int c, snd_seq_event_t *ev);
long snd_midi_event_encode(struct snd_midi_event *dev, unsigned char *buf, long count,
struct snd_seq_event *ev);
int snd_midi_event_encode_byte(struct snd_midi_event *dev, int c, struct snd_seq_event *ev);
/* decode from event to bytes - return number of written bytes if success */
long snd_midi_event_decode(snd_midi_event_t *dev, unsigned char *buf, long count, snd_seq_event_t *ev);
long snd_midi_event_decode(struct snd_midi_event *dev, unsigned char *buf, long count,
struct snd_seq_event *ev);
#endif /* __SOUND_SEQ_MIDI_EVENT_H */
include/sound/seq_virmidi.h
浏览文件 @ c7e0b5bf
......@@ -25,25 +25,23 @@
#include "rawmidi.h"
#include "seq_midi_event.h"
typedef struct _snd_virmidi_dev snd_virmidi_dev_t;
/*
* device file instance:
* This instance is created at each time the midi device file is
* opened. Each instance has its own input buffer and MIDI parser
* (buffer), and is associated with the device instance.
*/
typedef struct _snd_virmidi {
struct snd_virmidi {
struct list_head list;
int seq_mode;
int client;
int port;
unsigned int trigger: 1;
snd_midi_event_t *parser;
snd_seq_event_t event;
snd_virmidi_dev_t *rdev;
snd_rawmidi_substream_t *substream;
} snd_virmidi_t;
struct snd_midi_event *parser;
struct snd_seq_event event;
struct snd_virmidi_dev *rdev;
struct snd_rawmidi_substream *substream;
};
#define SNDRV_VIRMIDI_SUBSCRIBE (1<<0)
#define SNDRV_VIRMIDI_USE (1<<1)
......@@ -53,9 +51,9 @@ typedef struct _snd_virmidi {
* Each virtual midi device has one device instance. It contains
* common information and the linked-list of opened files,
*/
struct _snd_virmidi_dev {
snd_card_t *card; /* associated card */
snd_rawmidi_t *rmidi; /* rawmidi device */
struct snd_virmidi_dev {
struct snd_card *card; /* associated card */
struct snd_rawmidi *rmidi; /* rawmidi device */
int seq_mode; /* SNDRV_VIRMIDI_XXX */
int device; /* sequencer device */
int client; /* created/attached client */
......@@ -78,6 +76,6 @@ struct _snd_virmidi_dev {
#define SNDRV_VIRMIDI_SEQ_ATTACH 1
#define SNDRV_VIRMIDI_SEQ_DISPATCH 2
int snd_virmidi_new(snd_card_t *card, int device, snd_rawmidi_t **rrmidi);
int snd_virmidi_new(struct snd_card *card, int device, struct snd_rawmidi **rrmidi);
#endif /* __SOUND_SEQ_VIRMIDI */
sound/core/seq/seq_clientmgr.c
浏览文件 @ c7e0b5bf
此差异已折叠。
sound/core/seq/seq_clientmgr.h
浏览文件 @ c7e0b5bf
......@@ -30,24 +30,24 @@
/* client manager */
struct _snd_seq_user_client {
struct snd_seq_user_client {
struct file *file; /* file struct of client */
/* ... */
/* fifo */
fifo_t *fifo; /* queue for incoming events */
struct snd_seq_fifo *fifo; /* queue for incoming events */
int fifo_pool_size;
};
struct _snd_seq_kernel_client {
snd_card_t *card;
struct snd_seq_kernel_client {
struct snd_card *card;
/* pointer to client functions */
void *private_data; /* private data for client */
/* ... */
};
struct _snd_seq_client {
struct snd_seq_client {
snd_seq_client_type_t type;
unsigned int accept_input: 1,
accept_output: 1;
......@@ -65,40 +65,42 @@ struct _snd_seq_client {
int convert32; /* convert 32->64bit */
/* output pool */
pool_t *pool; /* memory pool for this client */
struct snd_seq_pool *pool; /* memory pool for this client */
union {
user_client_t user;
kernel_client_t kernel;
struct snd_seq_user_client user;
struct snd_seq_kernel_client kernel;
} data;
};
/* usage statistics */
typedef struct {
struct snd_seq_usage {
int cur;
int peak;
} usage_t;
};
extern int client_init_data(void);
extern int snd_sequencer_device_init(void);
extern void snd_sequencer_device_done(void);
int client_init_data(void);
int snd_sequencer_device_init(void);
void snd_sequencer_device_done(void);
/* get locked pointer to client */
extern client_t *snd_seq_client_use_ptr(int clientid);
struct snd_seq_client *snd_seq_client_use_ptr(int clientid);
/* unlock pointer to client */
#define snd_seq_client_unlock(client) snd_use_lock_free(&(client)->use_lock)
/* dispatch event to client(s) */
extern int snd_seq_dispatch_event(snd_seq_event_cell_t *cell, int atomic, int hop);
int snd_seq_dispatch_event(struct snd_seq_event_cell *cell, int atomic, int hop);
/* exported to other modules */
extern int snd_seq_register_kernel_client(snd_seq_client_callback_t *callback, void *private_data);
extern int snd_seq_unregister_kernel_client(int client);
extern int snd_seq_kernel_client_enqueue(int client, snd_seq_event_t *ev, int atomic, int hop);
int snd_seq_kernel_client_enqueue_blocking(int client, snd_seq_event_t * ev, struct file *file, int atomic, int hop);
int snd_seq_register_kernel_client(struct snd_seq_client_callback *callback, void *private_data);
int snd_seq_unregister_kernel_client(int client);
int snd_seq_kernel_client_enqueue(int client, struct snd_seq_event *ev, int atomic, int hop);
int snd_seq_kernel_client_enqueue_blocking(int client, struct snd_seq_event * ev,
struct file *file, int atomic, int hop);
int snd_seq_kernel_client_write_poll(int clientid, struct file *file, poll_table *wait);
int snd_seq_client_notify_subscription(int client, int port, snd_seq_port_subscribe_t *info, int evtype);
int snd_seq_client_notify_subscription(int client, int port,
struct snd_seq_port_subscribe *info, int evtype);
#endif
sound/core/seq/seq_compat.c
浏览文件 @ c7e0b5bf
......@@ -22,8 +22,8 @@
#include <linux/compat.h>
struct sndrv_seq_port_info32 {
struct sndrv_seq_addr addr; /* client/port numbers */
struct snd_seq_port_info32 {
struct snd_seq_addr addr; /* client/port numbers */
char name[64]; /* port name */
u32 capability; /* port capability bits */
......@@ -41,11 +41,11 @@ struct sndrv_seq_port_info32 {
char reserved[59]; /* for future use */
};
static int snd_seq_call_port_info_ioctl(client_t *client, unsigned int cmd,
struct sndrv_seq_port_info32 __user *data32)
static int snd_seq_call_port_info_ioctl(struct snd_seq_client *client, unsigned int cmd,
struct snd_seq_port_info32 __user *data32)
{
int err = -EFAULT;
snd_seq_port_info_t *data;
struct snd_seq_port_info *data;
mm_segment_t fs;
data = kmalloc(sizeof(*data), GFP_KERNEL);
......@@ -80,16 +80,16 @@ static int snd_seq_call_port_info_ioctl(client_t *client, unsigned int cmd,
*/
enum {
SNDRV_SEQ_IOCTL_CREATE_PORT32 = _IOWR('S', 0x20, struct sndrv_seq_port_info32),
SNDRV_SEQ_IOCTL_DELETE_PORT32 = _IOW ('S', 0x21, struct sndrv_seq_port_info32),
SNDRV_SEQ_IOCTL_GET_PORT_INFO32 = _IOWR('S', 0x22, struct sndrv_seq_port_info32),
SNDRV_SEQ_IOCTL_SET_PORT_INFO32 = _IOW ('S', 0x23, struct sndrv_seq_port_info32),
SNDRV_SEQ_IOCTL_QUERY_NEXT_PORT32 = _IOWR('S', 0x52, struct sndrv_seq_port_info32),
SNDRV_SEQ_IOCTL_CREATE_PORT32 = _IOWR('S', 0x20, struct snd_seq_port_info32),
SNDRV_SEQ_IOCTL_DELETE_PORT32 = _IOW ('S', 0x21, struct snd_seq_port_info32),
SNDRV_SEQ_IOCTL_GET_PORT_INFO32 = _IOWR('S', 0x22, struct snd_seq_port_info32),
SNDRV_SEQ_IOCTL_SET_PORT_INFO32 = _IOW ('S', 0x23, struct snd_seq_port_info32),
SNDRV_SEQ_IOCTL_QUERY_NEXT_PORT32 = _IOWR('S', 0x52, struct snd_seq_port_info32),
};
static long snd_seq_ioctl_compat(struct file *file, unsigned int cmd, unsigned long arg)
{
client_t *client = (client_t *) file->private_data;
struct snd_seq_client *client = file->private_data;
void __user *argp = compat_ptr(arg);
snd_assert(client != NULL, return -ENXIO);
......
sound/core/seq/seq_device.c
浏览文件 @ c7e0b5bf
......@@ -50,11 +50,6 @@ MODULE_AUTHOR("Takashi Iwai <tiwai@suse.de>");
MODULE_DESCRIPTION("ALSA sequencer device management");
MODULE_LICENSE("GPL");
/*
* driver list
*/
typedef struct ops_list ops_list_t;
/* driver state */
#define DRIVER_EMPTY 0
#define DRIVER_LOADED (1<<0)
......@@ -68,7 +63,7 @@ struct ops_list {
int argsize; /* argument size */
/* operators */
snd_seq_dev_ops_t ops;
struct snd_seq_dev_ops ops;
/* registred devices */
struct list_head dev_list; /* list of devices */
......@@ -83,35 +78,36 @@ struct ops_list {
static LIST_HEAD(opslist);
static int num_ops;
static DECLARE_MUTEX(ops_mutex);
static snd_info_entry_t *info_entry = NULL;
static struct snd_info_entry *info_entry = NULL;
/*
* prototypes
*/
static int snd_seq_device_free(snd_seq_device_t *dev);
static int snd_seq_device_dev_free(snd_device_t *device);
static int snd_seq_device_dev_register(snd_device_t *device);
static int snd_seq_device_dev_disconnect(snd_device_t *device);
static int snd_seq_device_dev_unregister(snd_device_t *device);
static int init_device(snd_seq_device_t *dev, ops_list_t *ops);
static int free_device(snd_seq_device_t *dev, ops_list_t *ops);
static ops_list_t *find_driver(char *id, int create_if_empty);
static ops_list_t *create_driver(char *id);
static void unlock_driver(ops_list_t *ops);
static int snd_seq_device_free(struct snd_seq_device *dev);
static int snd_seq_device_dev_free(struct snd_device *device);
static int snd_seq_device_dev_register(struct snd_device *device);
static int snd_seq_device_dev_disconnect(struct snd_device *device);
static int snd_seq_device_dev_unregister(struct snd_device *device);
static int init_device(struct snd_seq_device *dev, struct ops_list *ops);
static int free_device(struct snd_seq_device *dev, struct ops_list *ops);
static struct ops_list *find_driver(char *id, int create_if_empty);
static struct ops_list *create_driver(char *id);
static void unlock_driver(struct ops_list *ops);
static void remove_drivers(void);
/*
* show all drivers and their status
*/
static void snd_seq_device_info(snd_info_entry_t *entry, snd_info_buffer_t * buffer)
static void snd_seq_device_info(struct snd_info_entry *entry,
struct snd_info_buffer *buffer)
{
struct list_head *head;
down(&ops_mutex);
list_for_each(head, &opslist) {
ops_list_t *ops = list_entry(head, ops_list_t, list);
struct ops_list *ops = list_entry(head, struct ops_list, list);
snd_iprintf(buffer, "snd-%s%s%s%s,%d\n",
ops->id,
ops->driver & DRIVER_LOADED ? ",loaded" : (ops->driver == DRIVER_EMPTY ? ",empty" : ""),
......@@ -156,7 +152,7 @@ void snd_seq_device_load_drivers(void)
down(&ops_mutex);
list_for_each(head, &opslist) {
ops_list_t *ops = list_entry(head, ops_list_t, list);
struct ops_list *ops = list_entry(head, struct ops_list, list);
if (! (ops->driver & DRIVER_LOADED) &&
! (ops->driver & DRIVER_REQUESTED)) {
ops->used++;
......@@ -178,13 +174,13 @@ void snd_seq_device_load_drivers(void)
* id = id of driver
* result = return pointer (NULL allowed if unnecessary)
*/
int snd_seq_device_new(snd_card_t *card, int device, char *id, int argsize,
snd_seq_device_t **result)
int snd_seq_device_new(struct snd_card *card, int device, char *id, int argsize,
struct snd_seq_device **result)
{
snd_seq_device_t *dev;
ops_list_t *ops;
struct snd_seq_device *dev;
struct ops_list *ops;
int err;
static snd_device_ops_t dops = {
static struct snd_device_ops dops = {
.dev_free = snd_seq_device_dev_free,
.dev_register = snd_seq_device_dev_register,
.dev_disconnect = snd_seq_device_dev_disconnect,
......@@ -235,9 +231,9 @@ int snd_seq_device_new(snd_card_t *card, int device, char *id, int argsize,
/*
* free the existing device
*/
static int snd_seq_device_free(snd_seq_device_t *dev)
static int snd_seq_device_free(struct snd_seq_device *dev)
{
ops_list_t *ops;
struct ops_list *ops;
snd_assert(dev != NULL, return -EINVAL);
......@@ -261,19 +257,19 @@ static int snd_seq_device_free(snd_seq_device_t *dev)
return 0;
}
static int snd_seq_device_dev_free(snd_device_t *device)
static int snd_seq_device_dev_free(struct snd_device *device)
{
snd_seq_device_t *dev = device->device_data;
struct snd_seq_device *dev = device->device_data;
return snd_seq_device_free(dev);
}
/*
* register the device
*/
static int snd_seq_device_dev_register(snd_device_t *device)
static int snd_seq_device_dev_register(struct snd_device *device)
{
snd_seq_device_t *dev = device->device_data;
ops_list_t *ops;
struct snd_seq_device *dev = device->device_data;
struct ops_list *ops;
ops = find_driver(dev->id, 0);
if (ops == NULL)
......@@ -292,10 +288,10 @@ static int snd_seq_device_dev_register(snd_device_t *device)
/*
* disconnect the device
*/
static int snd_seq_device_dev_disconnect(snd_device_t *device)
static int snd_seq_device_dev_disconnect(struct snd_device *device)
{
snd_seq_device_t *dev = device->device_data;
ops_list_t *ops;
struct snd_seq_device *dev = device->device_data;
struct ops_list *ops;
ops = find_driver(dev->id, 0);
if (ops == NULL)
......@@ -310,9 +306,9 @@ static int snd_seq_device_dev_disconnect(snd_device_t *device)
/*
* unregister the existing device
*/
static int snd_seq_device_dev_unregister(snd_device_t *device)
static int snd_seq_device_dev_unregister(struct snd_device *device)
{
snd_seq_device_t *dev = device->device_data;
struct snd_seq_device *dev = device->device_data;
return snd_seq_device_free(dev);
}
......@@ -321,10 +317,11 @@ static int snd_seq_device_dev_unregister(snd_device_t *device)
* id = driver id
* entry = driver operators - duplicated to each instance
*/
int snd_seq_device_register_driver(char *id, snd_seq_dev_ops_t *entry, int argsize)
int snd_seq_device_register_driver(char *id, struct snd_seq_dev_ops *entry,
int argsize)
{
struct list_head *head;
ops_list_t *ops;
struct ops_list *ops;
if (id == NULL || entry == NULL ||
entry->init_device == NULL || entry->free_device == NULL)
......@@ -351,7 +348,7 @@ int snd_seq_device_register_driver(char *id, snd_seq_dev_ops_t *entry, int argsi
/* initialize existing devices if necessary */
list_for_each(head, &ops->dev_list) {
snd_seq_device_t *dev = list_entry(head, snd_seq_device_t, list);
struct snd_seq_device *dev = list_entry(head, struct snd_seq_device, list);
init_device(dev, ops);
}
up(&ops->reg_mutex);
......@@ -366,9 +363,9 @@ int snd_seq_device_register_driver(char *id, snd_seq_dev_ops_t *entry, int argsi
/*
* create driver record
*/
static ops_list_t * create_driver(char *id)
static struct ops_list * create_driver(char *id)
{
ops_list_t *ops;
struct ops_list *ops;
ops = kmalloc(sizeof(*ops), GFP_KERNEL);
if (ops == NULL)
......@@ -399,14 +396,15 @@ static ops_list_t * create_driver(char *id)
int snd_seq_device_unregister_driver(char *id)
{
struct list_head *head;
ops_list_t *ops;
struct ops_list *ops;
ops = find_driver(id, 0);
if (ops == NULL)
return -ENXIO;
if (! (ops->driver & DRIVER_LOADED) ||
(ops->driver & DRIVER_LOCKED)) {
snd_printk(KERN_ERR "driver_unregister: cannot unload driver '%s': status=%x\n", id, ops->driver);
snd_printk(KERN_ERR "driver_unregister: cannot unload driver '%s': status=%x\n",
id, ops->driver);
unlock_driver(ops);
return -EBUSY;
}
......@@ -415,13 +413,14 @@ int snd_seq_device_unregister_driver(char *id)
down(&ops->reg_mutex);
ops->driver |= DRIVER_LOCKED; /* do not remove this driver recursively */
list_for_each(head, &ops->dev_list) {
snd_seq_device_t *dev = list_entry(head, snd_seq_device_t, list);
struct snd_seq_device *dev = list_entry(head, struct snd_seq_device, list);
free_device(dev, ops);
}
ops->driver = 0;
if (ops->num_init_devices > 0)
snd_printk(KERN_ERR "free_driver: init_devices > 0!! (%d)\n", ops->num_init_devices);
snd_printk(KERN_ERR "free_driver: init_devices > 0!! (%d)\n",
ops->num_init_devices);
up(&ops->reg_mutex);
unlock_driver(ops);
......@@ -443,7 +442,7 @@ static void remove_drivers(void)
down(&ops_mutex);
head = opslist.next;
while (head != &opslist) {
ops_list_t *ops = list_entry(head, ops_list_t, list);
struct ops_list *ops = list_entry(head, struct ops_list, list);
if (! (ops->driver & DRIVER_LOADED) &&
ops->used == 0 && ops->num_devices == 0) {
head = head->next;
......@@ -459,21 +458,23 @@ static void remove_drivers(void)
/*
* initialize the device - call init_device operator
*/
static int init_device(snd_seq_device_t *dev, ops_list_t *ops)
static int init_device(struct snd_seq_device *dev, struct ops_list *ops)
{
if (! (ops->driver & DRIVER_LOADED))
return 0; /* driver is not loaded yet */
if (dev->status != SNDRV_SEQ_DEVICE_FREE)
return 0; /* already initialized */
if (ops->argsize != dev->argsize) {
snd_printk(KERN_ERR "incompatible device '%s' for plug-in '%s' (%d %d)\n", dev->name, ops->id, ops->argsize, dev->argsize);
snd_printk(KERN_ERR "incompatible device '%s' for plug-in '%s' (%d %d)\n",
dev->name, ops->id, ops->argsize, dev->argsize);
return -EINVAL;
}
if (ops->ops.init_device(dev) >= 0) {
dev->status = SNDRV_SEQ_DEVICE_REGISTERED;
ops->num_init_devices++;
} else {
snd_printk(KERN_ERR "init_device failed: %s: %s\n", dev->name, dev->id);
snd_printk(KERN_ERR "init_device failed: %s: %s\n",
dev->name, dev->id);
}
return 0;
......@@ -482,7 +483,7 @@ static int init_device(snd_seq_device_t *dev, ops_list_t *ops)
/*
* release the device - call free_device operator
*/
static int free_device(snd_seq_device_t *dev, ops_list_t *ops)
static int free_device(struct snd_seq_device *dev, struct ops_list *ops)
{
int result;
......@@ -491,7 +492,8 @@ static int free_device(snd_seq_device_t *dev, ops_list_t *ops)
if (dev->status != SNDRV_SEQ_DEVICE_REGISTERED)
return 0; /* not registered */
if (ops->argsize != dev->argsize) {
snd_printk(KERN_ERR "incompatible device '%s' for plug-in '%s' (%d %d)\n", dev->name, ops->id, ops->argsize, dev->argsize);
snd_printk(KERN_ERR "incompatible device '%s' for plug-in '%s' (%d %d)\n",
dev->name, ops->id, ops->argsize, dev->argsize);
return -EINVAL;
}
if ((result = ops->ops.free_device(dev)) >= 0 || result == -ENXIO) {
......@@ -499,7 +501,8 @@ static int free_device(snd_seq_device_t *dev, ops_list_t *ops)
dev->driver_data = NULL;
ops->num_init_devices--;
} else {
snd_printk(KERN_ERR "free_device failed: %s: %s\n", dev->name, dev->id);
snd_printk(KERN_ERR "free_device failed: %s: %s\n",
dev->name, dev->id);
}
return 0;
......@@ -508,13 +511,13 @@ static int free_device(snd_seq_device_t *dev, ops_list_t *ops)
/*
* find the matching driver with given id
*/
static ops_list_t * find_driver(char *id, int create_if_empty)
static struct ops_list * find_driver(char *id, int create_if_empty)
{
struct list_head *head;
down(&ops_mutex);
list_for_each(head, &opslist) {
ops_list_t *ops = list_entry(head, ops_list_t, list);
struct ops_list *ops = list_entry(head, struct ops_list, list);
if (strcmp(ops->id, id) == 0) {
ops->used++;
up(&ops_mutex);
......@@ -527,7 +530,7 @@ static ops_list_t * find_driver(char *id, int create_if_empty)
return NULL;
}
static void unlock_driver(ops_list_t *ops)
static void unlock_driver(struct ops_list *ops)
{
down(&ops_mutex);
ops->used--;
......@@ -541,7 +544,8 @@ static void unlock_driver(ops_list_t *ops)
static int __init alsa_seq_device_init(void)
{
info_entry = snd_info_create_module_entry(THIS_MODULE, "drivers", snd_seq_root);
info_entry = snd_info_create_module_entry(THIS_MODULE, "drivers",
snd_seq_root);
if (info_entry == NULL)
return -ENOMEM;
info_entry->content = SNDRV_INFO_CONTENT_TEXT;
......
sound/core/seq/seq_dummy.c
浏览文件 @ c7e0b5bf
......@@ -73,12 +73,12 @@ MODULE_PARM_DESC(ports, "number of ports to be created");
module_param(duplex, bool, 0444);
MODULE_PARM_DESC(duplex, "create DUPLEX ports");
typedef struct snd_seq_dummy_port {
struct snd_seq_dummy_port {
int client;
int port;
int duplex;
int connect;
} snd_seq_dummy_port_t;
};
static int my_client = -1;
......@@ -88,11 +88,11 @@ static int my_client = -1;
* Note: this callback is called only after all subscribers are removed.
*/
static int
dummy_unuse(void *private_data, snd_seq_port_subscribe_t *info)
dummy_unuse(void *private_data, struct snd_seq_port_subscribe *info)
{
snd_seq_dummy_port_t *p;
struct snd_seq_dummy_port *p;
int i;
snd_seq_event_t ev;
struct snd_seq_event ev;
p = private_data;
memset(&ev, 0, sizeof(ev));
......@@ -116,10 +116,11 @@ dummy_unuse(void *private_data, snd_seq_port_subscribe_t *info)
* event input callback - just redirect events to subscribers
*/
static int
dummy_input(snd_seq_event_t *ev, int direct, void *private_data, int atomic, int hop)
dummy_input(struct snd_seq_event *ev, int direct, void *private_data,
int atomic, int hop)
{
snd_seq_dummy_port_t *p;
snd_seq_event_t tmpev;
struct snd_seq_dummy_port *p;
struct snd_seq_event tmpev;
p = private_data;
if (ev->source.client == SNDRV_SEQ_CLIENT_SYSTEM ||
......@@ -146,12 +147,12 @@ dummy_free(void *private_data)
/*
* create a port
*/
static snd_seq_dummy_port_t __init *
static struct snd_seq_dummy_port __init *
create_port(int idx, int type)
{
snd_seq_port_info_t pinfo;
snd_seq_port_callback_t pcb;
snd_seq_dummy_port_t *rec;
struct snd_seq_port_info pinfo;
struct snd_seq_port_callback pcb;
struct snd_seq_dummy_port *rec;
if ((rec = kzalloc(sizeof(*rec), GFP_KERNEL)) == NULL)
return NULL;
......@@ -192,9 +193,9 @@ create_port(int idx, int type)
static int __init
register_client(void)
{
snd_seq_client_callback_t cb;
snd_seq_client_info_t cinfo;
snd_seq_dummy_port_t *rec1, *rec2;
struct snd_seq_client_callback cb;
struct snd_seq_client_info cinfo;
struct snd_seq_dummy_port *rec1, *rec2;
int i;
if (ports < 1) {
......
sound/core/seq/seq_fifo.c
浏览文件 @ c7e0b5bf
......@@ -29,9 +29,9 @@
/* FIFO */
/* create new fifo */
fifo_t *snd_seq_fifo_new(int poolsize)
struct snd_seq_fifo *snd_seq_fifo_new(int poolsize)
{
fifo_t *f;
struct snd_seq_fifo *f;
f = kzalloc(sizeof(*f), GFP_KERNEL);
if (f == NULL) {
......@@ -62,9 +62,9 @@ fifo_t *snd_seq_fifo_new(int poolsize)
return f;
}
void snd_seq_fifo_delete(fifo_t **fifo)
void snd_seq_fifo_delete(struct snd_seq_fifo **fifo)
{
fifo_t *f;
struct snd_seq_fifo *f;
snd_assert(fifo != NULL, return);
f = *fifo;
......@@ -88,12 +88,12 @@ void snd_seq_fifo_delete(fifo_t **fifo)
kfree(f);
}
static snd_seq_event_cell_t *fifo_cell_out(fifo_t *f);
static struct snd_seq_event_cell *fifo_cell_out(struct snd_seq_fifo *f);
/* clear queue */
void snd_seq_fifo_clear(fifo_t *f)
void snd_seq_fifo_clear(struct snd_seq_fifo *f)
{
snd_seq_event_cell_t *cell;
struct snd_seq_event_cell *cell;
unsigned long flags;
/* clear overflow flag */
......@@ -110,9 +110,10 @@ void snd_seq_fifo_clear(fifo_t *f)
/* enqueue event to fifo */
int snd_seq_fifo_event_in(fifo_t *f, snd_seq_event_t *event)
int snd_seq_fifo_event_in(struct snd_seq_fifo *f,
struct snd_seq_event *event)
{
snd_seq_event_cell_t *cell;
struct snd_seq_event_cell *cell;
unsigned long flags;
int err;
......@@ -148,9 +149,9 @@ int snd_seq_fifo_event_in(fifo_t *f, snd_seq_event_t *event)
}
/* dequeue cell from fifo */
static snd_seq_event_cell_t *fifo_cell_out(fifo_t *f)
static struct snd_seq_event_cell *fifo_cell_out(struct snd_seq_fifo *f)
{
snd_seq_event_cell_t *cell;
struct snd_seq_event_cell *cell;
if ((cell = f->head) != NULL) {
f->head = cell->next;
......@@ -167,9 +168,10 @@ static snd_seq_event_cell_t *fifo_cell_out(fifo_t *f)
}
/* dequeue cell from fifo and copy on user space */
int snd_seq_fifo_cell_out(fifo_t *f, snd_seq_event_cell_t **cellp, int nonblock)
int snd_seq_fifo_cell_out(struct snd_seq_fifo *f,
struct snd_seq_event_cell **cellp, int nonblock)
{
snd_seq_event_cell_t *cell;
struct snd_seq_event_cell *cell;
unsigned long flags;
wait_queue_t wait;
......@@ -202,7 +204,8 @@ int snd_seq_fifo_cell_out(fifo_t *f, snd_seq_event_cell_t **cellp, int nonblock)
}
void snd_seq_fifo_cell_putback(fifo_t *f, snd_seq_event_cell_t *cell)
void snd_seq_fifo_cell_putback(struct snd_seq_fifo *f,
struct snd_seq_event_cell *cell)
{
unsigned long flags;
......@@ -217,18 +220,19 @@ void snd_seq_fifo_cell_putback(fifo_t *f, snd_seq_event_cell_t *cell)
/* polling; return non-zero if queue is available */
int snd_seq_fifo_poll_wait(fifo_t *f, struct file *file, poll_table *wait)
int snd_seq_fifo_poll_wait(struct snd_seq_fifo *f, struct file *file,
poll_table *wait)
{
poll_wait(file, &f->input_sleep, wait);
return (f->cells > 0);
}
/* change the size of pool; all old events are removed */
int snd_seq_fifo_resize(fifo_t *f, int poolsize)
int snd_seq_fifo_resize(struct snd_seq_fifo *f, int poolsize)
{
unsigned long flags;
pool_t *newpool, *oldpool;
snd_seq_event_cell_t *cell, *next, *oldhead;
struct snd_seq_pool *newpool, *oldpool;
struct snd_seq_event_cell *cell, *next, *oldhead;
snd_assert(f != NULL && f->pool != NULL, return -EINVAL);
......
sound/core/seq/seq_fifo.h
浏览文件 @ c7e0b5bf
......@@ -27,46 +27,46 @@
/* === FIFO === */
typedef struct {
pool_t *pool; /* FIFO pool */
snd_seq_event_cell_t* head; /* pointer to head of fifo */
snd_seq_event_cell_t* tail; /* pointer to tail of fifo */
struct snd_seq_fifo {
struct snd_seq_pool *pool; /* FIFO pool */
struct snd_seq_event_cell *head; /* pointer to head of fifo */
struct snd_seq_event_cell *tail; /* pointer to tail of fifo */
int cells;
spinlock_t lock;
snd_use_lock_t use_lock;
wait_queue_head_t input_sleep;
atomic_t overflow;
} fifo_t;
};
/* create new fifo (constructor) */
extern fifo_t *snd_seq_fifo_new(int poolsize);
struct snd_seq_fifo *snd_seq_fifo_new(int poolsize);
/* delete fifo (destructor) */
extern void snd_seq_fifo_delete(fifo_t **f);
void snd_seq_fifo_delete(struct snd_seq_fifo **f);
/* enqueue event to fifo */
extern int snd_seq_fifo_event_in(fifo_t *f, snd_seq_event_t *event);
int snd_seq_fifo_event_in(struct snd_seq_fifo *f, struct snd_seq_event *event);
/* lock fifo from release */
#define snd_seq_fifo_lock(fifo) snd_use_lock_use(&(fifo)->use_lock)
#define snd_seq_fifo_unlock(fifo) snd_use_lock_free(&(fifo)->use_lock)
/* get a cell from fifo - fifo should be locked */
int snd_seq_fifo_cell_out(fifo_t *f, snd_seq_event_cell_t **cellp, int nonblock);
int snd_seq_fifo_cell_out(struct snd_seq_fifo *f, struct snd_seq_event_cell **cellp, int nonblock);
/* free dequeued cell - fifo should be locked */
extern void snd_seq_fifo_cell_putback(fifo_t *f, snd_seq_event_cell_t *cell);
void snd_seq_fifo_cell_putback(struct snd_seq_fifo *f, struct snd_seq_event_cell *cell);
/* clean up queue */
extern void snd_seq_fifo_clear(fifo_t *f);
void snd_seq_fifo_clear(struct snd_seq_fifo *f);
/* polling */
extern int snd_seq_fifo_poll_wait(fifo_t *f, struct file *file, poll_table *wait);
int snd_seq_fifo_poll_wait(struct snd_seq_fifo *f, struct file *file, poll_table *wait);
/* resize pool in fifo */
int snd_seq_fifo_resize(fifo_t *f, int poolsize);
int snd_seq_fifo_resize(struct snd_seq_fifo *f, int poolsize);
#endif
sound/core/seq/seq_info.c
浏览文件 @ c7e0b5bf
......@@ -28,15 +28,16 @@
#include "seq_timer.h"
static snd_info_entry_t *queues_entry;
static snd_info_entry_t *clients_entry;
static snd_info_entry_t *timer_entry;
static struct snd_info_entry *queues_entry;
static struct snd_info_entry *clients_entry;
static struct snd_info_entry *timer_entry;
static snd_info_entry_t * __init
create_info_entry(char *name, int size, void (*read)(snd_info_entry_t *, snd_info_buffer_t *))
static struct snd_info_entry * __init
create_info_entry(char *name, int size, void (*read)(struct snd_info_entry *,
struct snd_info_buffer *))
{
snd_info_entry_t *entry;
struct snd_info_entry *entry;
entry = snd_info_create_module_entry(THIS_MODULE, name, snd_seq_root);
if (entry == NULL)
......
sound/core/seq/seq_info.h
浏览文件 @ c7e0b5bf
......@@ -24,9 +24,9 @@
#include <sound/info.h>
#include <sound/seq_kernel.h>
void snd_seq_info_clients_read(snd_info_entry_t *entry, snd_info_buffer_t * buffer);
void snd_seq_info_timer_read(snd_info_entry_t *entry, snd_info_buffer_t * buffer);
void snd_seq_info_queues_read(snd_info_entry_t *entry, snd_info_buffer_t * buffer);
void snd_seq_info_clients_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer);
void snd_seq_info_timer_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer);
void snd_seq_info_queues_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer);
int snd_seq_info_init( void );
......
sound/core/seq/seq_instr.c
浏览文件 @ c7e0b5bf
......@@ -31,7 +31,7 @@ MODULE_DESCRIPTION("Advanced Linux Sound Architecture sequencer instrument libra
MODULE_LICENSE("GPL");
static void snd_instr_lock_ops(snd_seq_kinstr_list_t *list)
static void snd_instr_lock_ops(struct snd_seq_kinstr_list *list)
{
if (!(list->flags & SNDRV_SEQ_INSTR_FLG_DIRECT)) {
spin_lock_irqsave(&list->ops_lock, list->ops_flags);
......@@ -40,7 +40,7 @@ static void snd_instr_lock_ops(snd_seq_kinstr_list_t *list)
}
}
static void snd_instr_unlock_ops(snd_seq_kinstr_list_t *list)
static void snd_instr_unlock_ops(struct snd_seq_kinstr_list *list)
{
if (!(list->flags & SNDRV_SEQ_INSTR_FLG_DIRECT)) {
spin_unlock_irqrestore(&list->ops_lock, list->ops_flags);
......@@ -49,18 +49,18 @@ static void snd_instr_unlock_ops(snd_seq_kinstr_list_t *list)
}
}
static snd_seq_kinstr_t *snd_seq_instr_new(int add_len, int atomic)
static struct snd_seq_kinstr *snd_seq_instr_new(int add_len, int atomic)
{
snd_seq_kinstr_t *instr;
struct snd_seq_kinstr *instr;
instr = kzalloc(sizeof(snd_seq_kinstr_t) + add_len, atomic ? GFP_ATOMIC : GFP_KERNEL);
instr = kzalloc(sizeof(struct snd_seq_kinstr) + add_len, atomic ? GFP_ATOMIC : GFP_KERNEL);
if (instr == NULL)
return NULL;
instr->add_len = add_len;
return instr;
}
static int snd_seq_instr_free(snd_seq_kinstr_t *instr, int atomic)
static int snd_seq_instr_free(struct snd_seq_kinstr *instr, int atomic)
{
int result = 0;
......@@ -73,11 +73,11 @@ static int snd_seq_instr_free(snd_seq_kinstr_t *instr, int atomic)
return result;
}
snd_seq_kinstr_list_t *snd_seq_instr_list_new(void)
struct snd_seq_kinstr_list *snd_seq_instr_list_new(void)
{
snd_seq_kinstr_list_t *list;
struct snd_seq_kinstr_list *list;
list = kzalloc(sizeof(snd_seq_kinstr_list_t), GFP_KERNEL);
list = kzalloc(sizeof(struct snd_seq_kinstr_list), GFP_KERNEL);
if (list == NULL)
return NULL;
spin_lock_init(&list->lock);
......@@ -87,11 +87,11 @@ snd_seq_kinstr_list_t *snd_seq_instr_list_new(void)
return list;
}
void snd_seq_instr_list_free(snd_seq_kinstr_list_t **list_ptr)
void snd_seq_instr_list_free(struct snd_seq_kinstr_list **list_ptr)
{
snd_seq_kinstr_list_t *list;
snd_seq_kinstr_t *instr;
snd_seq_kcluster_t *cluster;
struct snd_seq_kinstr_list *list;
struct snd_seq_kinstr *instr;
struct snd_seq_kcluster *cluster;
int idx;
unsigned long flags;
......@@ -125,8 +125,8 @@ void snd_seq_instr_list_free(snd_seq_kinstr_list_t **list_ptr)
kfree(list);
}
static int instr_free_compare(snd_seq_kinstr_t *instr,
snd_seq_instr_header_t *ifree,
static int instr_free_compare(struct snd_seq_kinstr *instr,
struct snd_seq_instr_header *ifree,
unsigned int client)
{
switch (ifree->cmd) {
......@@ -160,12 +160,12 @@ static int instr_free_compare(snd_seq_kinstr_t *instr,
return 1;
}
int snd_seq_instr_list_free_cond(snd_seq_kinstr_list_t *list,
snd_seq_instr_header_t *ifree,
int snd_seq_instr_list_free_cond(struct snd_seq_kinstr_list *list,
struct snd_seq_instr_header *ifree,
int client,
int atomic)
{
snd_seq_kinstr_t *instr, *prev, *next, *flist;
struct snd_seq_kinstr *instr, *prev, *next, *flist;
int idx;
unsigned long flags;
......@@ -209,7 +209,7 @@ int snd_seq_instr_list_free_cond(snd_seq_kinstr_list_t *list,
return 0;
}
static int compute_hash_instr_key(snd_seq_instr_t *instr)
static int compute_hash_instr_key(struct snd_seq_instr *instr)
{
int result;
......@@ -233,7 +233,7 @@ static int compute_hash_cluster_key(snd_seq_instr_cluster_t cluster)
}
#endif
static int compare_instr(snd_seq_instr_t *i1, snd_seq_instr_t *i2, int exact)
static int compare_instr(struct snd_seq_instr *i1, struct snd_seq_instr *i2, int exact)
{
if (exact) {
if (i1->cluster != i2->cluster ||
......@@ -262,14 +262,14 @@ static int compare_instr(snd_seq_instr_t *i1, snd_seq_instr_t *i2, int exact)
}
}
snd_seq_kinstr_t *snd_seq_instr_find(snd_seq_kinstr_list_t *list,
snd_seq_instr_t *instr,
int exact,
int follow_alias)
struct snd_seq_kinstr *snd_seq_instr_find(struct snd_seq_kinstr_list *list,
struct snd_seq_instr *instr,
int exact,
int follow_alias)
{
unsigned long flags;
int depth = 0;
snd_seq_kinstr_t *result;
struct snd_seq_kinstr *result;
if (list == NULL || instr == NULL)
return NULL;
......@@ -279,7 +279,7 @@ snd_seq_kinstr_t *snd_seq_instr_find(snd_seq_kinstr_list_t *list,
while (result) {
if (!compare_instr(&result->instr, instr, exact)) {
if (follow_alias && (result->type == SNDRV_SEQ_INSTR_ATYPE_ALIAS)) {
instr = (snd_seq_instr_t *)KINSTR_DATA(result);
instr = (struct snd_seq_instr *)KINSTR_DATA(result);
if (++depth > 10)
goto __not_found;
goto __again;
......@@ -295,8 +295,8 @@ snd_seq_kinstr_t *snd_seq_instr_find(snd_seq_kinstr_list_t *list,
return NULL;
}
void snd_seq_instr_free_use(snd_seq_kinstr_list_t *list,
snd_seq_kinstr_t *instr)
void snd_seq_instr_free_use(struct snd_seq_kinstr_list *list,
struct snd_seq_kinstr *instr)
{
unsigned long flags;
......@@ -311,7 +311,8 @@ void snd_seq_instr_free_use(snd_seq_kinstr_list_t *list,
spin_unlock_irqrestore(&list->lock, flags);
}
static snd_seq_kinstr_ops_t *instr_ops(snd_seq_kinstr_ops_t *ops, char *instr_type)
static struct snd_seq_kinstr_ops *instr_ops(struct snd_seq_kinstr_ops *ops,
char *instr_type)
{
while (ops) {
if (!strcmp(ops->instr_type, instr_type))
......@@ -321,11 +322,11 @@ static snd_seq_kinstr_ops_t *instr_ops(snd_seq_kinstr_ops_t *ops, char *instr_ty
return NULL;
}
static int instr_result(snd_seq_event_t *ev,
static int instr_result(struct snd_seq_event *ev,
int type, int result,
int atomic)
{
snd_seq_event_t sev;
struct snd_seq_event sev;
memset(&sev, 0, sizeof(sev));
sev.type = SNDRV_SEQ_EVENT_RESULT;
......@@ -345,9 +346,9 @@ static int instr_result(snd_seq_event_t *ev,
return snd_seq_kernel_client_dispatch(sev.source.client, &sev, atomic, 0);
}
static int instr_begin(snd_seq_kinstr_ops_t *ops,
snd_seq_kinstr_list_t *list,
snd_seq_event_t *ev,
static int instr_begin(struct snd_seq_kinstr_ops *ops,
struct snd_seq_kinstr_list *list,
struct snd_seq_event *ev,
int atomic, int hop)
{
unsigned long flags;
......@@ -362,9 +363,9 @@ static int instr_begin(snd_seq_kinstr_ops_t *ops,
return instr_result(ev, SNDRV_SEQ_EVENT_INSTR_BEGIN, 0, atomic);
}
static int instr_end(snd_seq_kinstr_ops_t *ops,
snd_seq_kinstr_list_t *list,
snd_seq_event_t *ev,
static int instr_end(struct snd_seq_kinstr_ops *ops,
struct snd_seq_kinstr_list *list,
struct snd_seq_event *ev,
int atomic, int hop)
{
unsigned long flags;
......@@ -380,54 +381,55 @@ static int instr_end(snd_seq_kinstr_ops_t *ops,
return instr_result(ev, SNDRV_SEQ_EVENT_INSTR_END, -EINVAL, atomic);
}
static int instr_info(snd_seq_kinstr_ops_t *ops,
snd_seq_kinstr_list_t *list,
snd_seq_event_t *ev,
static int instr_info(struct snd_seq_kinstr_ops *ops,
struct snd_seq_kinstr_list *list,
struct snd_seq_event *ev,
int atomic, int hop)
{
return -ENXIO;
}
static int instr_format_info(snd_seq_kinstr_ops_t *ops,
snd_seq_kinstr_list_t *list,
snd_seq_event_t *ev,
static int instr_format_info(struct snd_seq_kinstr_ops *ops,
struct snd_seq_kinstr_list *list,
struct snd_seq_event *ev,
int atomic, int hop)
{
return -ENXIO;
}
static int instr_reset(snd_seq_kinstr_ops_t *ops,
snd_seq_kinstr_list_t *list,
snd_seq_event_t *ev,
static int instr_reset(struct snd_seq_kinstr_ops *ops,
struct snd_seq_kinstr_list *list,
struct snd_seq_event *ev,
int atomic, int hop)
{
return -ENXIO;
}
static int instr_status(snd_seq_kinstr_ops_t *ops,
snd_seq_kinstr_list_t *list,
snd_seq_event_t *ev,
static int instr_status(struct snd_seq_kinstr_ops *ops,
struct snd_seq_kinstr_list *list,
struct snd_seq_event *ev,
int atomic, int hop)
{
return -ENXIO;
}
static int instr_put(snd_seq_kinstr_ops_t *ops,
snd_seq_kinstr_list_t *list,
snd_seq_event_t *ev,
static int instr_put(struct snd_seq_kinstr_ops *ops,
struct snd_seq_kinstr_list *list,
struct snd_seq_event *ev,
int atomic, int hop)
{
unsigned long flags;
snd_seq_instr_header_t put;
snd_seq_kinstr_t *instr;
struct snd_seq_instr_header put;
struct snd_seq_kinstr *instr;
int result = -EINVAL, len, key;
if ((ev->flags & SNDRV_SEQ_EVENT_LENGTH_MASK) != SNDRV_SEQ_EVENT_LENGTH_VARUSR)
goto __return;
if (ev->data.ext.len < sizeof(snd_seq_instr_header_t))
if (ev->data.ext.len < sizeof(struct snd_seq_instr_header))
goto __return;
if (copy_from_user(&put, (void __user *)ev->data.ext.ptr, sizeof(snd_seq_instr_header_t))) {
if (copy_from_user(&put, (void __user *)ev->data.ext.ptr,
sizeof(struct snd_seq_instr_header))) {
result = -EFAULT;
goto __return;
}
......@@ -449,7 +451,7 @@ static int instr_put(snd_seq_kinstr_ops_t *ops,
}
len = ops->add_len;
if (put.data.type == SNDRV_SEQ_INSTR_ATYPE_ALIAS)
len = sizeof(snd_seq_instr_t);
len = sizeof(struct snd_seq_instr);
instr = snd_seq_instr_new(len, atomic);
if (instr == NULL) {
snd_instr_unlock_ops(list);
......@@ -463,8 +465,8 @@ static int instr_put(snd_seq_kinstr_ops_t *ops,
if (instr->type == SNDRV_SEQ_INSTR_ATYPE_DATA) {
result = ops->put(ops->private_data,
instr,
(void __user *)ev->data.ext.ptr + sizeof(snd_seq_instr_header_t),
ev->data.ext.len - sizeof(snd_seq_instr_header_t),
(void __user *)ev->data.ext.ptr + sizeof(struct snd_seq_instr_header),
ev->data.ext.len - sizeof(struct snd_seq_instr_header),
atomic,
put.cmd);
if (result < 0) {
......@@ -486,21 +488,21 @@ static int instr_put(snd_seq_kinstr_ops_t *ops,
return result;
}
static int instr_get(snd_seq_kinstr_ops_t *ops,
snd_seq_kinstr_list_t *list,
snd_seq_event_t *ev,
static int instr_get(struct snd_seq_kinstr_ops *ops,
struct snd_seq_kinstr_list *list,
struct snd_seq_event *ev,
int atomic, int hop)
{
return -ENXIO;
}
static int instr_free(snd_seq_kinstr_ops_t *ops,
snd_seq_kinstr_list_t *list,
snd_seq_event_t *ev,
static int instr_free(struct snd_seq_kinstr_ops *ops,
struct snd_seq_kinstr_list *list,
struct snd_seq_event *ev,
int atomic, int hop)
{
snd_seq_instr_header_t ifree;
snd_seq_kinstr_t *instr, *prev;
struct snd_seq_instr_header ifree;
struct snd_seq_kinstr *instr, *prev;
int result = -EINVAL;
unsigned long flags;
unsigned int hash;
......@@ -508,9 +510,10 @@ static int instr_free(snd_seq_kinstr_ops_t *ops,
if ((ev->flags & SNDRV_SEQ_EVENT_LENGTH_MASK) != SNDRV_SEQ_EVENT_LENGTH_VARUSR)
goto __return;
if (ev->data.ext.len < sizeof(snd_seq_instr_header_t))
if (ev->data.ext.len < sizeof(struct snd_seq_instr_header))
goto __return;
if (copy_from_user(&ifree, (void __user *)ev->data.ext.ptr, sizeof(snd_seq_instr_header_t))) {
if (copy_from_user(&ifree, (void __user *)ev->data.ext.ptr,
sizeof(struct snd_seq_instr_header))) {
result = -EFAULT;
goto __return;
}
......@@ -548,7 +551,8 @@ static int instr_free(snd_seq_kinstr_ops_t *ops,
list->hash[hash] = instr->next;
}
if (instr->ops && instr->ops->notify)
instr->ops->notify(instr->ops->private_data, instr, SNDRV_SEQ_INSTR_NOTIFY_REMOVE);
instr->ops->notify(instr->ops->private_data, instr,
SNDRV_SEQ_INSTR_NOTIFY_REMOVE);
while (instr->use) {
spin_unlock_irqrestore(&list->lock, flags);
schedule_timeout_interruptible(1);
......@@ -565,25 +569,25 @@ static int instr_free(snd_seq_kinstr_ops_t *ops,
return result;
}
static int instr_list(snd_seq_kinstr_ops_t *ops,
snd_seq_kinstr_list_t *list,
snd_seq_event_t *ev,
static int instr_list(struct snd_seq_kinstr_ops *ops,
struct snd_seq_kinstr_list *list,
struct snd_seq_event *ev,
int atomic, int hop)
{
return -ENXIO;
}
static int instr_cluster(snd_seq_kinstr_ops_t *ops,
snd_seq_kinstr_list_t *list,
snd_seq_event_t *ev,
static int instr_cluster(struct snd_seq_kinstr_ops *ops,
struct snd_seq_kinstr_list *list,
struct snd_seq_event *ev,
int atomic, int hop)
{
return -ENXIO;
}
int snd_seq_instr_event(snd_seq_kinstr_ops_t *ops,
snd_seq_kinstr_list_t *list,
snd_seq_event_t *ev,
int snd_seq_instr_event(struct snd_seq_kinstr_ops *ops,
struct snd_seq_kinstr_list *list,
struct snd_seq_event *ev,
int client,
int atomic,
int hop)
......
sound/core/seq/seq_memory.c
浏览文件 @ c7e0b5bf
......@@ -36,12 +36,12 @@
#define semaphore_of(fp) ((fp)->f_dentry->d_inode->i_sem)
static inline int snd_seq_pool_available(pool_t *pool)
static inline int snd_seq_pool_available(struct snd_seq_pool *pool)
{
return pool->total_elements - atomic_read(&pool->counter);
}
static inline int snd_seq_output_ok(pool_t *pool)
static inline int snd_seq_output_ok(struct snd_seq_pool *pool)
{
return snd_seq_pool_available(pool) >= pool->room;
}
......@@ -72,7 +72,7 @@ static inline int snd_seq_output_ok(pool_t *pool)
* call dump function to expand external data.
*/
static int get_var_len(const snd_seq_event_t *event)
static int get_var_len(const struct snd_seq_event *event)
{
if ((event->flags & SNDRV_SEQ_EVENT_LENGTH_MASK) != SNDRV_SEQ_EVENT_LENGTH_VARIABLE)
return -EINVAL;
......@@ -80,10 +80,11 @@ static int get_var_len(const snd_seq_event_t *event)
return event->data.ext.len & ~SNDRV_SEQ_EXT_MASK;
}
int snd_seq_dump_var_event(const snd_seq_event_t *event, snd_seq_dump_func_t func, void *private_data)
int snd_seq_dump_var_event(const struct snd_seq_event *event,
snd_seq_dump_func_t func, void *private_data)
{
int len, err;
snd_seq_event_cell_t *cell;
struct snd_seq_event_cell *cell;
if ((len = get_var_len(event)) <= 0)
return len;
......@@ -108,9 +109,9 @@ int snd_seq_dump_var_event(const snd_seq_event_t *event, snd_seq_dump_func_t fun
return func(private_data, event->data.ext.ptr, len);
}
cell = (snd_seq_event_cell_t*)event->data.ext.ptr;
cell = (struct snd_seq_event_cell *)event->data.ext.ptr;
for (; len > 0 && cell; cell = cell->next) {
int size = sizeof(snd_seq_event_t);
int size = sizeof(struct snd_seq_event);
if (len < size)
size = len;
err = func(private_data, &cell->event, size);
......@@ -142,7 +143,8 @@ static int seq_copy_in_user(char __user **bufptr, const void *src, int size)
return 0;
}
int snd_seq_expand_var_event(const snd_seq_event_t *event, int count, char *buf, int in_kernel, int size_aligned)
int snd_seq_expand_var_event(const struct snd_seq_event *event, int count, char *buf,
int in_kernel, int size_aligned)
{
int len, newlen;
int err;
......@@ -174,17 +176,18 @@ int snd_seq_expand_var_event(const snd_seq_event_t *event, int count, char *buf,
* release this cell, free extended data if available
*/
static inline void free_cell(pool_t *pool, snd_seq_event_cell_t *cell)
static inline void free_cell(struct snd_seq_pool *pool,
struct snd_seq_event_cell *cell)
{
cell->next = pool->free;
pool->free = cell;
atomic_dec(&pool->counter);
}
void snd_seq_cell_free(snd_seq_event_cell_t * cell)
void snd_seq_cell_free(struct snd_seq_event_cell * cell)
{
unsigned long flags;
pool_t *pool;
struct snd_seq_pool *pool;
snd_assert(cell != NULL, return);
pool = cell->pool;
......@@ -194,7 +197,7 @@ void snd_seq_cell_free(snd_seq_event_cell_t * cell)
free_cell(pool, cell);
if (snd_seq_ev_is_variable(&cell->event)) {
if (cell->event.data.ext.len & SNDRV_SEQ_EXT_CHAINED) {
snd_seq_event_cell_t *curp, *nextptr;
struct snd_seq_event_cell *curp, *nextptr;
curp = cell->event.data.ext.ptr;
for (; curp; curp = nextptr) {
nextptr = curp->next;
......@@ -215,9 +218,11 @@ void snd_seq_cell_free(snd_seq_event_cell_t * cell)
/*
* allocate an event cell.
*/
static int snd_seq_cell_alloc(pool_t *pool, snd_seq_event_cell_t **cellp, int nonblock, struct file *file)
static int snd_seq_cell_alloc(struct snd_seq_pool *pool,
struct snd_seq_event_cell **cellp,
int nonblock, struct file *file)
{
snd_seq_event_cell_t *cell;
struct snd_seq_event_cell *cell;
unsigned long flags;
int err = -EAGAIN;
wait_queue_t wait;
......@@ -280,11 +285,13 @@ static int snd_seq_cell_alloc(pool_t *pool, snd_seq_event_cell_t **cellp, int no
* if the event has external data, the data is decomposed to additional
* cells.
*/
int snd_seq_event_dup(pool_t *pool, snd_seq_event_t *event, snd_seq_event_cell_t **cellp, int nonblock, struct file *file)
int snd_seq_event_dup(struct snd_seq_pool *pool, struct snd_seq_event *event,
struct snd_seq_event_cell **cellp, int nonblock,
struct file *file)
{
int ncells, err;
unsigned int extlen;
snd_seq_event_cell_t *cell;
struct snd_seq_event_cell *cell;
*cellp = NULL;
......@@ -292,7 +299,7 @@ int snd_seq_event_dup(pool_t *pool, snd_seq_event_t *event, snd_seq_event_cell_t
extlen = 0;
if (snd_seq_ev_is_variable(event)) {
extlen = event->data.ext.len & ~SNDRV_SEQ_EXT_MASK;
ncells = (extlen + sizeof(snd_seq_event_t) - 1) / sizeof(snd_seq_event_t);
ncells = (extlen + sizeof(struct snd_seq_event) - 1) / sizeof(struct snd_seq_event);
}
if (ncells >= pool->total_elements)
return -ENOMEM;
......@@ -309,18 +316,18 @@ int snd_seq_event_dup(pool_t *pool, snd_seq_event_t *event, snd_seq_event_cell_t
int len = extlen;
int is_chained = event->data.ext.len & SNDRV_SEQ_EXT_CHAINED;
int is_usrptr = event->data.ext.len & SNDRV_SEQ_EXT_USRPTR;
snd_seq_event_cell_t *src, *tmp, *tail;
struct snd_seq_event_cell *src, *tmp, *tail;
char *buf;
cell->event.data.ext.len = extlen | SNDRV_SEQ_EXT_CHAINED;
cell->event.data.ext.ptr = NULL;
src = (snd_seq_event_cell_t*)event->data.ext.ptr;
src = (struct snd_seq_event_cell *)event->data.ext.ptr;
buf = (char *)event->data.ext.ptr;
tail = NULL;
while (ncells-- > 0) {
int size = sizeof(snd_seq_event_t);
int size = sizeof(struct snd_seq_event);
if (len < size)
size = len;
err = snd_seq_cell_alloc(pool, &tmp, nonblock, file);
......@@ -358,7 +365,8 @@ int snd_seq_event_dup(pool_t *pool, snd_seq_event_t *event, snd_seq_event_cell_t
/* poll wait */
int snd_seq_pool_poll_wait(pool_t *pool, struct file *file, poll_table *wait)
int snd_seq_pool_poll_wait(struct snd_seq_pool *pool, struct file *file,
poll_table *wait)
{
poll_wait(file, &pool->output_sleep, wait);
return snd_seq_output_ok(pool);
......@@ -366,17 +374,17 @@ int snd_seq_pool_poll_wait(pool_t *pool, struct file *file, poll_table *wait)
/* allocate room specified number of events */
int snd_seq_pool_init(pool_t *pool)
int snd_seq_pool_init(struct snd_seq_pool *pool)
{
int cell;
snd_seq_event_cell_t *cellptr;
struct snd_seq_event_cell *cellptr;
unsigned long flags;
snd_assert(pool != NULL, return -EINVAL);
if (pool->ptr) /* should be atomic? */
return 0;
pool->ptr = vmalloc(sizeof(snd_seq_event_cell_t) * pool->size);
pool->ptr = vmalloc(sizeof(struct snd_seq_event_cell) * pool->size);
if (pool->ptr == NULL) {
snd_printd("seq: malloc for sequencer events failed\n");
return -ENOMEM;
......@@ -402,10 +410,10 @@ int snd_seq_pool_init(pool_t *pool)
}
/* remove events */
int snd_seq_pool_done(pool_t *pool)
int snd_seq_pool_done(struct snd_seq_pool *pool)
{
unsigned long flags;
snd_seq_event_cell_t *ptr;
struct snd_seq_event_cell *ptr;
int max_count = 5 * HZ;
snd_assert(pool != NULL, return -EINVAL);
......@@ -446,9 +454,9 @@ int snd_seq_pool_done(pool_t *pool)
/* init new memory pool */
pool_t *snd_seq_pool_new(int poolsize)
struct snd_seq_pool *snd_seq_pool_new(int poolsize)
{
pool_t *pool;
struct snd_seq_pool *pool;
/* create pool block */
pool = kzalloc(sizeof(*pool), GFP_KERNEL);
......@@ -472,9 +480,9 @@ pool_t *snd_seq_pool_new(int poolsize)
}
/* remove memory pool */
int snd_seq_pool_delete(pool_t **ppool)
int snd_seq_pool_delete(struct snd_seq_pool **ppool)
{
pool_t *pool = *ppool;
struct snd_seq_pool *pool = *ppool;
*ppool = NULL;
if (pool == NULL)
......@@ -497,7 +505,8 @@ void __exit snd_sequencer_memory_done(void)
/* exported to seq_clientmgr.c */
void snd_seq_info_pool(snd_info_buffer_t * buffer, pool_t *pool, char *space)
void snd_seq_info_pool(struct snd_info_buffer *buffer,
struct snd_seq_pool *pool, char *space)
{
if (pool == NULL)
return;
......
sound/core/seq/seq_memory.h
浏览文件 @ c7e0b5bf
......@@ -24,23 +24,21 @@
#include <sound/seq_kernel.h>
#include <linux/poll.h>
typedef struct pool pool_t;
/* container for sequencer event (internal use) */
typedef struct snd_seq_event_cell_t {
snd_seq_event_t event;
pool_t *pool; /* used pool */
struct snd_seq_event_cell_t *next; /* next cell */
} snd_seq_event_cell_t;
struct snd_seq_event_cell {
struct snd_seq_event event;
struct snd_seq_pool *pool; /* used pool */
struct snd_seq_event_cell *next; /* next cell */
};
/* design note: the pool is a contigious block of memory, if we dynamicly
want to add additional cells to the pool be better store this in another
pool as we need to know the base address of the pool when releasing
memory. */
struct pool {
snd_seq_event_cell_t *ptr; /* pointer to first event chunk */
snd_seq_event_cell_t *free; /* pointer to the head of the free list */
struct snd_seq_pool {
struct snd_seq_event_cell *ptr; /* pointer to first event chunk */
struct snd_seq_event_cell *free; /* pointer to the head of the free list */
int total_elements; /* pool size actually allocated */
atomic_t counter; /* cells free */
......@@ -63,33 +61,34 @@ struct pool {
spinlock_t lock;
};
extern void snd_seq_cell_free(snd_seq_event_cell_t* cell);
void snd_seq_cell_free(struct snd_seq_event_cell *cell);
int snd_seq_event_dup(pool_t *pool, snd_seq_event_t *event, snd_seq_event_cell_t **cellp, int nonblock, struct file *file);
int snd_seq_event_dup(struct snd_seq_pool *pool, struct snd_seq_event *event,
struct snd_seq_event_cell **cellp, int nonblock, struct file *file);
/* return number of unused (free) cells */
static inline int snd_seq_unused_cells(pool_t *pool)
static inline int snd_seq_unused_cells(struct snd_seq_pool *pool)
{
return pool ? pool->total_elements - atomic_read(&pool->counter) : 0;
}
/* return total number of allocated cells */
static inline int snd_seq_total_cells(pool_t *pool)
static inline int snd_seq_total_cells(struct snd_seq_pool *pool)
{
return pool ? pool->total_elements : 0;
}
/* init pool - allocate events */
int snd_seq_pool_init(pool_t *pool);
int snd_seq_pool_init(struct snd_seq_pool *pool);
/* done pool - free events */
int snd_seq_pool_done(pool_t *pool);
int snd_seq_pool_done(struct snd_seq_pool *pool);
/* create pool */
pool_t *snd_seq_pool_new(int poolsize);
struct snd_seq_pool *snd_seq_pool_new(int poolsize);
/* remove pool */
int snd_seq_pool_delete(pool_t **pool);
int snd_seq_pool_delete(struct snd_seq_pool **pool);
/* init memory */
int snd_sequencer_memory_init(void);
......@@ -98,7 +97,7 @@ int snd_sequencer_memory_init(void);
void snd_sequencer_memory_done(void);
/* polling */
int snd_seq_pool_poll_wait(pool_t *pool, struct file *file, poll_table *wait);
int snd_seq_pool_poll_wait(struct snd_seq_pool *pool, struct file *file, poll_table *wait);
#endif
sound/core/seq/seq_midi.c
浏览文件 @ c7e0b5bf
......@@ -51,40 +51,40 @@ module_param(input_buffer_size, int, 0644);
MODULE_PARM_DESC(input_buffer_size, "Input buffer size in bytes.");
/* data for this midi synth driver */
typedef struct {
snd_card_t *card;
struct seq_midisynth {
struct snd_card *card;
int device;
int subdevice;
snd_rawmidi_file_t input_rfile;
snd_rawmidi_file_t output_rfile;
struct snd_rawmidi_file input_rfile;
struct snd_rawmidi_file output_rfile;
int seq_client;
int seq_port;
snd_midi_event_t *parser;
} seq_midisynth_t;
struct snd_midi_event *parser;
};
typedef struct {
struct seq_midisynth_client {
int seq_client;
int num_ports;
int ports_per_device[SNDRV_RAWMIDI_DEVICES];
seq_midisynth_t *ports[SNDRV_RAWMIDI_DEVICES];
} seq_midisynth_client_t;
struct seq_midisynth *ports[SNDRV_RAWMIDI_DEVICES];
};
static seq_midisynth_client_t *synths[SNDRV_CARDS];
static struct seq_midisynth_client *synths[SNDRV_CARDS];
static DECLARE_MUTEX(register_mutex);
/* handle rawmidi input event (MIDI v1.0 stream) */
static void snd_midi_input_event(snd_rawmidi_substream_t * substream)
static void snd_midi_input_event(struct snd_rawmidi_substream *substream)
{
snd_rawmidi_runtime_t *runtime;
seq_midisynth_t *msynth;
snd_seq_event_t ev;
struct snd_rawmidi_runtime *runtime;
struct seq_midisynth *msynth;
struct snd_seq_event ev;
char buf[16], *pbuf;
long res, count;
if (substream == NULL)
return;
runtime = substream->runtime;
msynth = (seq_midisynth_t *) runtime->private_data;
msynth = runtime->private_data;
if (msynth == NULL)
return;
memset(&ev, 0, sizeof(ev));
......@@ -112,9 +112,9 @@ static void snd_midi_input_event(snd_rawmidi_substream_t * substream)
}
}
static int dump_midi(snd_rawmidi_substream_t *substream, const char *buf, int count)
static int dump_midi(struct snd_rawmidi_substream *substream, const char *buf, int count)
{
snd_rawmidi_runtime_t *runtime;
struct snd_rawmidi_runtime *runtime;
int tmp;
snd_assert(substream != NULL || buf != NULL, return -EINVAL);
......@@ -128,12 +128,12 @@ static int dump_midi(snd_rawmidi_substream_t *substream, const char *buf, int co
return 0;
}
static int event_process_midi(snd_seq_event_t * ev, int direct,
static int event_process_midi(struct snd_seq_event *ev, int direct,
void *private_data, int atomic, int hop)
{
seq_midisynth_t *msynth = (seq_midisynth_t *) private_data;
struct seq_midisynth *msynth = private_data;
unsigned char msg[10]; /* buffer for constructing midi messages */
snd_rawmidi_substream_t *substream;
struct snd_rawmidi_substream *substream;
int len;
snd_assert(msynth != NULL, return -EINVAL);
......@@ -161,8 +161,8 @@ static int event_process_midi(snd_seq_event_t * ev, int direct,
}
static int snd_seq_midisynth_new(seq_midisynth_t *msynth,
snd_card_t *card,
static int snd_seq_midisynth_new(struct seq_midisynth *msynth,
struct snd_card *card,
int device,
int subdevice)
{
......@@ -175,12 +175,12 @@ static int snd_seq_midisynth_new(seq_midisynth_t *msynth,
}
/* open associated midi device for input */
static int midisynth_subscribe(void *private_data, snd_seq_port_subscribe_t *info)
static int midisynth_subscribe(void *private_data, struct snd_seq_port_subscribe *info)
{
int err;
seq_midisynth_t *msynth = (seq_midisynth_t *)private_data;
snd_rawmidi_runtime_t *runtime;
snd_rawmidi_params_t params;
struct seq_midisynth *msynth = private_data;
struct snd_rawmidi_runtime *runtime;
struct snd_rawmidi_params params;
/* open midi port */
if ((err = snd_rawmidi_kernel_open(msynth->card->number, msynth->device, msynth->subdevice, SNDRV_RAWMIDI_LFLG_INPUT, &msynth->input_rfile)) < 0) {
......@@ -203,10 +203,10 @@ static int midisynth_subscribe(void *private_data, snd_seq_port_subscribe_t *inf
}
/* close associated midi device for input */
static int midisynth_unsubscribe(void *private_data, snd_seq_port_subscribe_t *info)
static int midisynth_unsubscribe(void *private_data, struct snd_seq_port_subscribe *info)
{
int err;
seq_midisynth_t *msynth = (seq_midisynth_t *)private_data;
struct seq_midisynth *msynth = private_data;
snd_assert(msynth->input_rfile.input != NULL, return -EINVAL);
err = snd_rawmidi_kernel_release(&msynth->input_rfile);
......@@ -214,11 +214,11 @@ static int midisynth_unsubscribe(void *private_data, snd_seq_port_subscribe_t *i
}
/* open associated midi device for output */
static int midisynth_use(void *private_data, snd_seq_port_subscribe_t *info)
static int midisynth_use(void *private_data, struct snd_seq_port_subscribe *info)
{
int err;
seq_midisynth_t *msynth = (seq_midisynth_t *)private_data;
snd_rawmidi_params_t params;
struct seq_midisynth *msynth = private_data;
struct snd_rawmidi_params params;
/* open midi port */
if ((err = snd_rawmidi_kernel_open(msynth->card->number, msynth->device, msynth->subdevice, SNDRV_RAWMIDI_LFLG_OUTPUT, &msynth->output_rfile)) < 0) {
......@@ -237,9 +237,9 @@ static int midisynth_use(void *private_data, snd_seq_port_subscribe_t *info)
}
/* close associated midi device for output */
static int midisynth_unuse(void *private_data, snd_seq_port_subscribe_t *info)
static int midisynth_unuse(void *private_data, struct snd_seq_port_subscribe *info)
{
seq_midisynth_t *msynth = (seq_midisynth_t *)private_data;
struct seq_midisynth *msynth = private_data;
unsigned char buf = 0xff; /* MIDI reset */
snd_assert(msynth->output_rfile.output != NULL, return -EINVAL);
......@@ -250,7 +250,7 @@ static int midisynth_unuse(void *private_data, snd_seq_port_subscribe_t *info)
}
/* delete given midi synth port */
static void snd_seq_midisynth_delete(seq_midisynth_t *msynth)
static void snd_seq_midisynth_delete(struct seq_midisynth *msynth)
{
if (msynth == NULL)
return;
......@@ -265,10 +265,10 @@ static void snd_seq_midisynth_delete(seq_midisynth_t *msynth)
}
/* set our client name */
static int set_client_name(seq_midisynth_client_t *client, snd_card_t *card,
snd_rawmidi_info_t *rmidi)
static int set_client_name(struct seq_midisynth_client *client, struct snd_card *card,
struct snd_rawmidi_info *rmidi)
{
snd_seq_client_info_t cinfo;
struct snd_seq_client_info cinfo;
const char *name;
memset(&cinfo, 0, sizeof(cinfo));
......@@ -281,17 +281,17 @@ static int set_client_name(seq_midisynth_client_t *client, snd_card_t *card,
/* register new midi synth port */
static int
snd_seq_midisynth_register_port(snd_seq_device_t *dev)
snd_seq_midisynth_register_port(struct snd_seq_device *dev)
{
seq_midisynth_client_t *client;
seq_midisynth_t *msynth, *ms;
snd_seq_port_info_t *port;
snd_rawmidi_info_t *info;
struct seq_midisynth_client *client;
struct seq_midisynth *msynth, *ms;
struct snd_seq_port_info *port;
struct snd_rawmidi_info *info;
int newclient = 0;
unsigned int p, ports;
snd_seq_client_callback_t callbacks;
snd_seq_port_callback_t pcallbacks;
snd_card_t *card = dev->card;
struct snd_seq_client_callback callbacks;
struct snd_seq_port_callback pcallbacks;
struct snd_card *card = dev->card;
int device = dev->device;
unsigned int input_count = 0, output_count = 0;
......@@ -342,7 +342,7 @@ snd_seq_midisynth_register_port(snd_seq_device_t *dev)
} else if (device == 0)
set_client_name(client, card, info); /* use the first device's name */
msynth = kcalloc(ports, sizeof(seq_midisynth_t), GFP_KERNEL);
msynth = kcalloc(ports, sizeof(struct seq_midisynth), GFP_KERNEL);
port = kmalloc(sizeof(*port), GFP_KERNEL);
if (msynth == NULL || port == NULL)
goto __nomem;
......@@ -432,11 +432,11 @@ snd_seq_midisynth_register_port(snd_seq_device_t *dev)
/* release midi synth port */
static int
snd_seq_midisynth_unregister_port(snd_seq_device_t *dev)
snd_seq_midisynth_unregister_port(struct snd_seq_device *dev)
{
seq_midisynth_client_t *client;
seq_midisynth_t *msynth;
snd_card_t *card = dev->card;
struct seq_midisynth_client *client;
struct seq_midisynth *msynth;
struct snd_card *card = dev->card;
int device = dev->device, p, ports;
down(&register_mutex);
......@@ -465,7 +465,7 @@ snd_seq_midisynth_unregister_port(snd_seq_device_t *dev)
static int __init alsa_seq_midi_init(void)
{
static snd_seq_dev_ops_t ops = {
static struct snd_seq_dev_ops ops = {
snd_seq_midisynth_register_port,
snd_seq_midisynth_unregister_port,
};
......
sound/core/seq/seq_midi_emul.c
浏览文件 @ c7e0b5bf
......@@ -44,17 +44,25 @@ MODULE_DESCRIPTION("Advanced Linux Sound Architecture sequencer MIDI emulation."
MODULE_LICENSE("GPL");
/* Prototypes for static functions */
static void note_off(snd_midi_op_t *ops, void *drv, snd_midi_channel_t *chan, int note, int vel);
static void do_control(snd_midi_op_t *ops, void *private,
snd_midi_channel_set_t *chset, snd_midi_channel_t *chan,
static void note_off(struct snd_midi_op *ops, void *drv,
struct snd_midi_channel *chan,
int note, int vel);
static void do_control(struct snd_midi_op *ops, void *private,
struct snd_midi_channel_set *chset,
struct snd_midi_channel *chan,
int control, int value);
static void rpn(snd_midi_op_t *ops, void *drv, snd_midi_channel_t *chan, snd_midi_channel_set_t *chset);
static void nrpn(snd_midi_op_t *ops, void *drv, snd_midi_channel_t *chan, snd_midi_channel_set_t *chset);
static void sysex(snd_midi_op_t *ops, void *private, unsigned char *sysex, int len, snd_midi_channel_set_t *chset);
static void all_sounds_off(snd_midi_op_t *ops, void *private, snd_midi_channel_t *chan);
static void all_notes_off(snd_midi_op_t *ops, void *private, snd_midi_channel_t *chan);
static void snd_midi_reset_controllers(snd_midi_channel_t *chan);
static void reset_all_channels(snd_midi_channel_set_t *chset);
static void rpn(struct snd_midi_op *ops, void *drv, struct snd_midi_channel *chan,
struct snd_midi_channel_set *chset);
static void nrpn(struct snd_midi_op *ops, void *drv, struct snd_midi_channel *chan,
struct snd_midi_channel_set *chset);
static void sysex(struct snd_midi_op *ops, void *private, unsigned char *sysex,
int len, struct snd_midi_channel_set *chset);
static void all_sounds_off(struct snd_midi_op *ops, void *private,
struct snd_midi_channel *chan);
static void all_notes_off(struct snd_midi_op *ops, void *private,
struct snd_midi_channel *chan);
static void snd_midi_reset_controllers(struct snd_midi_channel *chan);
static void reset_all_channels(struct snd_midi_channel_set *chset);
/*
......@@ -72,10 +80,11 @@ static void reset_all_channels(snd_midi_channel_set_t *chset);
* be interpreted.
*/
void
snd_midi_process_event(snd_midi_op_t *ops,
snd_seq_event_t *ev, snd_midi_channel_set_t *chanset)
snd_midi_process_event(struct snd_midi_op *ops,
struct snd_seq_event *ev,
struct snd_midi_channel_set *chanset)
{
snd_midi_channel_t *chan;
struct snd_midi_channel *chan;
void *drv;
int dest_channel = 0;
......@@ -89,7 +98,8 @@ snd_midi_process_event(snd_midi_op_t *ops,
if (snd_seq_ev_is_channel_type(ev)) {
dest_channel = ev->data.note.channel;
if (dest_channel >= chanset->max_channels) {
snd_printd("dest channel is %d, max is %d\n", dest_channel, chanset->max_channels);
snd_printd("dest channel is %d, max is %d\n",
dest_channel, chanset->max_channels);
return;
}
}
......@@ -239,7 +249,8 @@ snd_midi_process_event(snd_midi_op_t *ops,
* release note
*/
static void
note_off(snd_midi_op_t *ops, void *drv, snd_midi_channel_t *chan, int note, int vel)
note_off(struct snd_midi_op *ops, void *drv, struct snd_midi_channel *chan,
int note, int vel)
{
if (chan->gm_hold) {
/* Hold this note until pedal is turned off */
......@@ -260,8 +271,8 @@ note_off(snd_midi_op_t *ops, void *drv, snd_midi_channel_t *chan, int note, int
* events that need to take place immediately to the driver.
*/
static void
do_control(snd_midi_op_t *ops, void *drv, snd_midi_channel_set_t *chset,
snd_midi_channel_t *chan, int control, int value)
do_control(struct snd_midi_op *ops, void *drv, struct snd_midi_channel_set *chset,
struct snd_midi_channel *chan, int control, int value)
{
int i;
......@@ -376,7 +387,7 @@ do_control(snd_midi_op_t *ops, void *drv, snd_midi_channel_set_t *chset,
* initialize the MIDI status
*/
void
snd_midi_channel_set_clear(snd_midi_channel_set_t *chset)
snd_midi_channel_set_clear(struct snd_midi_channel_set *chset)
{
int i;
......@@ -384,7 +395,7 @@ snd_midi_channel_set_clear(snd_midi_channel_set_t *chset)
chset->gs_master_volume = 127;
for (i = 0; i < chset->max_channels; i++) {
snd_midi_channel_t *chan = chset->channels + i;
struct snd_midi_channel *chan = chset->channels + i;
memset(chan->note, 0, sizeof(chan->note));
chan->midi_aftertouch = 0;
......@@ -407,8 +418,8 @@ snd_midi_channel_set_clear(snd_midi_channel_set_t *chset)
* Process a rpn message.
*/
static void
rpn(snd_midi_op_t *ops, void *drv, snd_midi_channel_t *chan,
snd_midi_channel_set_t *chset)
rpn(struct snd_midi_op *ops, void *drv, struct snd_midi_channel *chan,
struct snd_midi_channel_set *chset)
{
int type;
int val;
......@@ -447,8 +458,8 @@ rpn(snd_midi_op_t *ops, void *drv, snd_midi_channel_t *chan,
* Process an nrpn message.
*/
static void
nrpn(snd_midi_op_t *ops, void *drv, snd_midi_channel_t *chan,
snd_midi_channel_set_t *chset)
nrpn(struct snd_midi_op *ops, void *drv, struct snd_midi_channel *chan,
struct snd_midi_channel_set *chset)
{
/* parse XG NRPNs here if possible */
if (ops->nrpn)
......@@ -475,7 +486,8 @@ get_channel(unsigned char cmd)
* Process a sysex message.
*/
static void
sysex(snd_midi_op_t *ops, void *private, unsigned char *buf, int len, snd_midi_channel_set_t *chset)
sysex(struct snd_midi_op *ops, void *private, unsigned char *buf, int len,
struct snd_midi_channel_set *chset)
{
/* GM on */
static unsigned char gm_on_macro[] = {
......@@ -588,7 +600,7 @@ sysex(snd_midi_op_t *ops, void *private, unsigned char *buf, int len, snd_midi_c
* all sound off
*/
static void
all_sounds_off(snd_midi_op_t *ops, void *drv, snd_midi_channel_t *chan)
all_sounds_off(struct snd_midi_op *ops, void *drv, struct snd_midi_channel *chan)
{
int n;
......@@ -606,7 +618,7 @@ all_sounds_off(snd_midi_op_t *ops, void *drv, snd_midi_channel_t *chan)
* all notes off
*/
static void
all_notes_off(snd_midi_op_t *ops, void *drv, snd_midi_channel_t *chan)
all_notes_off(struct snd_midi_op *ops, void *drv, struct snd_midi_channel *chan)
{
int n;
......@@ -621,12 +633,12 @@ all_notes_off(snd_midi_op_t *ops, void *drv, snd_midi_channel_t *chan)
/*
* Initialise a single midi channel control block.
*/
static void snd_midi_channel_init(snd_midi_channel_t *p, int n)
static void snd_midi_channel_init(struct snd_midi_channel *p, int n)
{
if (p == NULL)
return;
memset(p, 0, sizeof(snd_midi_channel_t));
memset(p, 0, sizeof(struct snd_midi_channel));
p->private = NULL;
p->number = n;
......@@ -642,12 +654,12 @@ static void snd_midi_channel_init(snd_midi_channel_t *p, int n)
/*
* Allocate and initialise a set of midi channel control blocks.
*/
static snd_midi_channel_t *snd_midi_channel_init_set(int n)
static struct snd_midi_channel *snd_midi_channel_init_set(int n)
{
snd_midi_channel_t *chan;
struct snd_midi_channel *chan;
int i;
chan = kmalloc(n * sizeof(snd_midi_channel_t), GFP_KERNEL);
chan = kmalloc(n * sizeof(struct snd_midi_channel), GFP_KERNEL);
if (chan) {
for (i = 0; i < n; i++)
snd_midi_channel_init(chan+i, i);
......@@ -660,11 +672,11 @@ static snd_midi_channel_t *snd_midi_channel_init_set(int n)
* reset all midi channels
*/
static void
reset_all_channels(snd_midi_channel_set_t *chset)
reset_all_channels(struct snd_midi_channel_set *chset)
{
int ch;
for (ch = 0; ch < chset->max_channels; ch++) {
snd_midi_channel_t *chan = chset->channels + ch;
struct snd_midi_channel *chan = chset->channels + ch;
snd_midi_reset_controllers(chan);
chan->gm_rpn_pitch_bend_range = 256; /* 2 semitones */
chan->gm_rpn_fine_tuning = 0;
......@@ -681,9 +693,9 @@ reset_all_channels(snd_midi_channel_set_t *chset)
/*
* Allocate and initialise a midi channel set.
*/
snd_midi_channel_set_t *snd_midi_channel_alloc_set(int n)
struct snd_midi_channel_set *snd_midi_channel_alloc_set(int n)
{
snd_midi_channel_set_t *chset;
struct snd_midi_channel_set *chset;
chset = kmalloc(sizeof(*chset), GFP_KERNEL);
if (chset) {
......@@ -697,7 +709,7 @@ snd_midi_channel_set_t *snd_midi_channel_alloc_set(int n)
/*
* Reset the midi controllers on a particular channel to default values.
*/
static void snd_midi_reset_controllers(snd_midi_channel_t *chan)
static void snd_midi_reset_controllers(struct snd_midi_channel *chan)
{
memset(chan->control, 0, sizeof(chan->control));
chan->gm_volume = 127;
......@@ -709,7 +721,7 @@ static void snd_midi_reset_controllers(snd_midi_channel_t *chan)
/*
* Free a midi channel set.
*/
void snd_midi_channel_free_set(snd_midi_channel_set_t *chset)
void snd_midi_channel_free_set(struct snd_midi_channel_set *chset)
{
if (chset == NULL)
return;
......
sound/core/seq/seq_midi_event.c
浏览文件 @ c7e0b5bf
......@@ -41,33 +41,29 @@ MODULE_LICENSE("GPL");
/* from 8 to 15 are events for 0xf0-0xf7 */
/* status event types */
typedef void (*event_encode_t)(snd_midi_event_t *dev, snd_seq_event_t *ev);
typedef void (*event_decode_t)(snd_seq_event_t *ev, unsigned char *buf);
/*
* prototypes
*/
static void note_event(snd_midi_event_t *dev, snd_seq_event_t *ev);
static void one_param_ctrl_event(snd_midi_event_t *dev, snd_seq_event_t *ev);
static void pitchbend_ctrl_event(snd_midi_event_t *dev, snd_seq_event_t *ev);
static void two_param_ctrl_event(snd_midi_event_t *dev, snd_seq_event_t *ev);
static void one_param_event(snd_midi_event_t *dev, snd_seq_event_t *ev);
static void songpos_event(snd_midi_event_t *dev, snd_seq_event_t *ev);
static void note_decode(snd_seq_event_t *ev, unsigned char *buf);
static void one_param_decode(snd_seq_event_t *ev, unsigned char *buf);
static void pitchbend_decode(snd_seq_event_t *ev, unsigned char *buf);
static void two_param_decode(snd_seq_event_t *ev, unsigned char *buf);
static void songpos_decode(snd_seq_event_t *ev, unsigned char *buf);
static void note_event(struct snd_midi_event *dev, struct snd_seq_event *ev);
static void one_param_ctrl_event(struct snd_midi_event *dev, struct snd_seq_event *ev);
static void pitchbend_ctrl_event(struct snd_midi_event *dev, struct snd_seq_event *ev);
static void two_param_ctrl_event(struct snd_midi_event *dev, struct snd_seq_event *ev);
static void one_param_event(struct snd_midi_event *dev, struct snd_seq_event *ev);
static void songpos_event(struct snd_midi_event *dev, struct snd_seq_event *ev);
static void note_decode(struct snd_seq_event *ev, unsigned char *buf);
static void one_param_decode(struct snd_seq_event *ev, unsigned char *buf);
static void pitchbend_decode(struct snd_seq_event *ev, unsigned char *buf);
static void two_param_decode(struct snd_seq_event *ev, unsigned char *buf);
static void songpos_decode(struct snd_seq_event *ev, unsigned char *buf);
/*
* event list
*/
static struct status_event_list_t {
static struct status_event_list {
int event;
int qlen;
event_encode_t encode;
event_decode_t decode;
void (*encode)(struct snd_midi_event *dev, struct snd_seq_event *ev);
void (*decode)(struct snd_seq_event *ev, unsigned char *buf);
} status_event[] = {
/* 0x80 - 0xf0 */
{SNDRV_SEQ_EVENT_NOTEOFF, 2, note_event, note_decode},
......@@ -97,12 +93,15 @@ static struct status_event_list_t {
{SNDRV_SEQ_EVENT_RESET, 0, NULL, NULL}, /* 0xff */
};
static int extra_decode_ctrl14(snd_midi_event_t *dev, unsigned char *buf, int len, snd_seq_event_t *ev);
static int extra_decode_xrpn(snd_midi_event_t *dev, unsigned char *buf, int count, snd_seq_event_t *ev);
static int extra_decode_ctrl14(struct snd_midi_event *dev, unsigned char *buf, int len,
struct snd_seq_event *ev);
static int extra_decode_xrpn(struct snd_midi_event *dev, unsigned char *buf, int count,
struct snd_seq_event *ev);
static struct extra_event_list_t {
static struct extra_event_list {
int event;
int (*decode)(snd_midi_event_t *dev, unsigned char *buf, int len, snd_seq_event_t *ev);
int (*decode)(struct snd_midi_event *dev, unsigned char *buf, int len,
struct snd_seq_event *ev);
} extra_event[] = {
{SNDRV_SEQ_EVENT_CONTROL14, extra_decode_ctrl14},
{SNDRV_SEQ_EVENT_NONREGPARAM, extra_decode_xrpn},
......@@ -113,9 +112,9 @@ static struct extra_event_list_t {
* new/delete record
*/
int snd_midi_event_new(int bufsize, snd_midi_event_t **rdev)
int snd_midi_event_new(int bufsize, struct snd_midi_event **rdev)
{
snd_midi_event_t *dev;
struct snd_midi_event *dev;
*rdev = NULL;
dev = kzalloc(sizeof(*dev), GFP_KERNEL);
......@@ -135,7 +134,7 @@ int snd_midi_event_new(int bufsize, snd_midi_event_t **rdev)
return 0;
}
void snd_midi_event_free(snd_midi_event_t *dev)
void snd_midi_event_free(struct snd_midi_event *dev)
{
if (dev != NULL) {
kfree(dev->buf);
......@@ -146,14 +145,14 @@ void snd_midi_event_free(snd_midi_event_t *dev)
/*
* initialize record
*/
static inline void reset_encode(snd_midi_event_t *dev)
static inline void reset_encode(struct snd_midi_event *dev)
{
dev->read = 0;
dev->qlen = 0;
dev->type = 0;
}
void snd_midi_event_reset_encode(snd_midi_event_t *dev)
void snd_midi_event_reset_encode(struct snd_midi_event *dev)
{
unsigned long flags;
......@@ -162,7 +161,7 @@ void snd_midi_event_reset_encode(snd_midi_event_t *dev)
spin_unlock_irqrestore(&dev->lock, flags);
}
void snd_midi_event_reset_decode(snd_midi_event_t *dev)
void snd_midi_event_reset_decode(struct snd_midi_event *dev)
{
unsigned long flags;
......@@ -172,14 +171,14 @@ void snd_midi_event_reset_decode(snd_midi_event_t *dev)
}
#if 0
void snd_midi_event_init(snd_midi_event_t *dev)
void snd_midi_event_init(struct snd_midi_event *dev)
{
snd_midi_event_reset_encode(dev);
snd_midi_event_reset_decode(dev);
}
#endif /* 0 */
void snd_midi_event_no_status(snd_midi_event_t *dev, int on)
void snd_midi_event_no_status(struct snd_midi_event *dev, int on)
{
dev->nostat = on ? 1 : 0;
}
......@@ -188,7 +187,7 @@ void snd_midi_event_no_status(snd_midi_event_t *dev, int on)
* resize buffer
*/
#if 0
int snd_midi_event_resize_buffer(snd_midi_event_t *dev, int bufsize)
int snd_midi_event_resize_buffer(struct snd_midi_event *dev, int bufsize)
{
unsigned char *new_buf, *old_buf;
unsigned long flags;
......@@ -213,7 +212,8 @@ int snd_midi_event_resize_buffer(snd_midi_event_t *dev, int bufsize)
* read bytes and encode to sequencer event if finished
* return the size of encoded bytes
*/
long snd_midi_event_encode(snd_midi_event_t *dev, unsigned char *buf, long count, snd_seq_event_t *ev)
long snd_midi_event_encode(struct snd_midi_event *dev, unsigned char *buf, long count,
struct snd_seq_event *ev)
{
long result = 0;
int rc;
......@@ -238,7 +238,8 @@ long snd_midi_event_encode(snd_midi_event_t *dev, unsigned char *buf, long count
* 0 data is not finished
* negative for error
*/
int snd_midi_event_encode_byte(snd_midi_event_t *dev, int c, snd_seq_event_t *ev)
int snd_midi_event_encode_byte(struct snd_midi_event *dev, int c,
struct snd_seq_event *ev)
{
int rc = 0;
unsigned long flags;
......@@ -303,7 +304,7 @@ int snd_midi_event_encode_byte(snd_midi_event_t *dev, int c, snd_seq_event_t *ev
}
/* encode note event */
static void note_event(snd_midi_event_t *dev, snd_seq_event_t *ev)
static void note_event(struct snd_midi_event *dev, struct snd_seq_event *ev)
{
ev->data.note.channel = dev->buf[0] & 0x0f;
ev->data.note.note = dev->buf[1];
......@@ -311,21 +312,21 @@ static void note_event(snd_midi_event_t *dev, snd_seq_event_t *ev)
}
/* encode one parameter controls */
static void one_param_ctrl_event(snd_midi_event_t *dev, snd_seq_event_t *ev)
static void one_param_ctrl_event(struct snd_midi_event *dev, struct snd_seq_event *ev)
{
ev->data.control.channel = dev->buf[0] & 0x0f;
ev->data.control.value = dev->buf[1];
}
/* encode pitch wheel change */
static void pitchbend_ctrl_event(snd_midi_event_t *dev, snd_seq_event_t *ev)
static void pitchbend_ctrl_event(struct snd_midi_event *dev, struct snd_seq_event *ev)
{
ev->data.control.channel = dev->buf[0] & 0x0f;
ev->data.control.value = (int)dev->buf[2] * 128 + (int)dev->buf[1] - 8192;
}
/* encode midi control change */
static void two_param_ctrl_event(snd_midi_event_t *dev, snd_seq_event_t *ev)
static void two_param_ctrl_event(struct snd_midi_event *dev, struct snd_seq_event *ev)
{
ev->data.control.channel = dev->buf[0] & 0x0f;
ev->data.control.param = dev->buf[1];
......@@ -333,13 +334,13 @@ static void two_param_ctrl_event(snd_midi_event_t *dev, snd_seq_event_t *ev)
}
/* encode one parameter value*/
static void one_param_event(snd_midi_event_t *dev, snd_seq_event_t *ev)
static void one_param_event(struct snd_midi_event *dev, struct snd_seq_event *ev)
{
ev->data.control.value = dev->buf[1];
}
/* encode song position */
static void songpos_event(snd_midi_event_t *dev, snd_seq_event_t *ev)
static void songpos_event(struct snd_midi_event *dev, struct snd_seq_event *ev)
{
ev->data.control.value = (int)dev->buf[2] * 128 + (int)dev->buf[1];
}
......@@ -348,7 +349,8 @@ static void songpos_event(snd_midi_event_t *dev, snd_seq_event_t *ev)
* decode from a sequencer event to midi bytes
* return the size of decoded midi events
*/
long snd_midi_event_decode(snd_midi_event_t *dev, unsigned char *buf, long count, snd_seq_event_t *ev)
long snd_midi_event_decode(struct snd_midi_event *dev, unsigned char *buf, long count,
struct snd_seq_event *ev)
{
unsigned int cmd, type;
......@@ -404,20 +406,20 @@ long snd_midi_event_decode(snd_midi_event_t *dev, unsigned char *buf, long count
/* decode note event */
static void note_decode(snd_seq_event_t *ev, unsigned char *buf)
static void note_decode(struct snd_seq_event *ev, unsigned char *buf)
{
buf[0] = ev->data.note.note & 0x7f;
buf[1] = ev->data.note.velocity & 0x7f;
}
/* decode one parameter controls */
static void one_param_decode(snd_seq_event_t *ev, unsigned char *buf)
static void one_param_decode(struct snd_seq_event *ev, unsigned char *buf)
{
buf[0] = ev->data.control.value & 0x7f;
}
/* decode pitch wheel change */
static void pitchbend_decode(snd_seq_event_t *ev, unsigned char *buf)
static void pitchbend_decode(struct snd_seq_event *ev, unsigned char *buf)
{
int value = ev->data.control.value + 8192;
buf[0] = value & 0x7f;
......@@ -425,21 +427,22 @@ static void pitchbend_decode(snd_seq_event_t *ev, unsigned char *buf)
}
/* decode midi control change */
static void two_param_decode(snd_seq_event_t *ev, unsigned char *buf)
static void two_param_decode(struct snd_seq_event *ev, unsigned char *buf)
{
buf[0] = ev->data.control.param & 0x7f;
buf[1] = ev->data.control.value & 0x7f;
}
/* decode song position */
static void songpos_decode(snd_seq_event_t *ev, unsigned char *buf)
static void songpos_decode(struct snd_seq_event *ev, unsigned char *buf)
{
buf[0] = ev->data.control.value & 0x7f;
buf[1] = (ev->data.control.value >> 7) & 0x7f;
}
/* decode 14bit control */
static int extra_decode_ctrl14(snd_midi_event_t *dev, unsigned char *buf, int count, snd_seq_event_t *ev)
static int extra_decode_ctrl14(struct snd_midi_event *dev, unsigned char *buf,
int count, struct snd_seq_event *ev)
{
unsigned char cmd;
int idx = 0;
......@@ -476,7 +479,8 @@ static int extra_decode_ctrl14(snd_midi_event_t *dev, unsigned char *buf, int co
}
/* decode reg/nonreg param */
static int extra_decode_xrpn(snd_midi_event_t *dev, unsigned char *buf, int count, snd_seq_event_t *ev)
static int extra_decode_xrpn(struct snd_midi_event *dev, unsigned char *buf,
int count, struct snd_seq_event *ev)
{
unsigned char cmd;
char *cbytes;
......
sound/core/seq/seq_ports.c
浏览文件 @ c7e0b5bf
......@@ -56,16 +56,17 @@ much elements are in array.
*/
/* return pointer to port structure - port is locked if found */
client_port_t *snd_seq_port_use_ptr(client_t *client, int num)
struct snd_seq_client_port *snd_seq_port_use_ptr(struct snd_seq_client *client,
int num)
{
struct list_head *p;
client_port_t *port;
struct snd_seq_client_port *port;
if (client == NULL)
return NULL;
read_lock(&client->ports_lock);
list_for_each(p, &client->ports_list_head) {
port = list_entry(p, client_port_t, list);
port = list_entry(p, struct snd_seq_client_port, list);
if (port->addr.port == num) {
if (port->closing)
break; /* deleting now */
......@@ -80,17 +81,18 @@ client_port_t *snd_seq_port_use_ptr(client_t *client, int num)
/* search for the next port - port is locked if found */
client_port_t *snd_seq_port_query_nearest(client_t *client, snd_seq_port_info_t *pinfo)
struct snd_seq_client_port *snd_seq_port_query_nearest(struct snd_seq_client *client,
struct snd_seq_port_info *pinfo)
{
int num;
struct list_head *p;
client_port_t *port, *found;
struct snd_seq_client_port *port, *found;
num = pinfo->addr.port;
found = NULL;
read_lock(&client->ports_lock);
list_for_each(p, &client->ports_list_head) {
port = list_entry(p, client_port_t, list);
port = list_entry(p, struct snd_seq_client_port, list);
if (port->addr.port < num)
continue;
if (port->addr.port == num) {
......@@ -111,8 +113,8 @@ client_port_t *snd_seq_port_query_nearest(client_t *client, snd_seq_port_info_t
}
/* initialize port_subs_info_t */
static void port_subs_info_init(port_subs_info_t *grp)
/* initialize snd_seq_port_subs_info */
static void port_subs_info_init(struct snd_seq_port_subs_info *grp)
{
INIT_LIST_HEAD(&grp->list_head);
grp->count = 0;
......@@ -125,10 +127,11 @@ static void port_subs_info_init(port_subs_info_t *grp)
/* create a port, port number is returned (-1 on failure) */
client_port_t *snd_seq_create_port(client_t *client, int port)
struct snd_seq_client_port *snd_seq_create_port(struct snd_seq_client *client,
int port)
{
unsigned long flags;
client_port_t *new_port;
struct snd_seq_client_port *new_port;
struct list_head *l;
int num = -1;
......@@ -159,7 +162,7 @@ client_port_t *snd_seq_create_port(client_t *client, int port)
down(&client->ports_mutex);
write_lock_irqsave(&client->ports_lock, flags);
list_for_each(l, &client->ports_list_head) {
client_port_t *p = list_entry(l, client_port_t, list);
struct snd_seq_client_port *p = list_entry(l, struct snd_seq_client_port, list);
if (p->addr.port > num)
break;
if (port < 0) /* auto-probe mode */
......@@ -177,17 +180,24 @@ client_port_t *snd_seq_create_port(client_t *client, int port)
}
/* */
enum group_type_t {
enum group_type {
SRC_LIST, DEST_LIST
};
static int subscribe_port(client_t *client, client_port_t *port, port_subs_info_t *grp, snd_seq_port_subscribe_t *info, int send_ack);
static int unsubscribe_port(client_t *client, client_port_t *port, port_subs_info_t *grp, snd_seq_port_subscribe_t *info, int send_ack);
static int subscribe_port(struct snd_seq_client *client,
struct snd_seq_client_port *port,
struct snd_seq_port_subs_info *grp,
struct snd_seq_port_subscribe *info, int send_ack);
static int unsubscribe_port(struct snd_seq_client *client,
struct snd_seq_client_port *port,
struct snd_seq_port_subs_info *grp,
struct snd_seq_port_subscribe *info, int send_ack);
static client_port_t *get_client_port(snd_seq_addr_t *addr, client_t **cp)
static struct snd_seq_client_port *get_client_port(struct snd_seq_addr *addr,
struct snd_seq_client **cp)
{
client_port_t *p;
struct snd_seq_client_port *p;
*cp = snd_seq_client_use_ptr(addr->client);
if (*cp) {
p = snd_seq_port_use_ptr(*cp, addr->port);
......@@ -204,22 +214,24 @@ static client_port_t *get_client_port(snd_seq_addr_t *addr, client_t **cp)
* remove all subscribers on the list
* this is called from port_delete, for each src and dest list.
*/
static void clear_subscriber_list(client_t *client, client_port_t *port,
port_subs_info_t *grp, int grptype)
static void clear_subscriber_list(struct snd_seq_client *client,
struct snd_seq_client_port *port,
struct snd_seq_port_subs_info *grp,
int grptype)
{
struct list_head *p, *n;
down_write(&grp->list_mutex);
list_for_each_safe(p, n, &grp->list_head) {
subscribers_t *subs;
client_t *c;
client_port_t *aport;
struct snd_seq_subscribers *subs;
struct snd_seq_client *c;
struct snd_seq_client_port *aport;
if (grptype == SRC_LIST) {
subs = list_entry(p, subscribers_t, src_list);
subs = list_entry(p, struct snd_seq_subscribers, src_list);
aport = get_client_port(&subs->info.dest, &c);
} else {
subs = list_entry(p, subscribers_t, dest_list);
subs = list_entry(p, struct snd_seq_subscribers, dest_list);
aport = get_client_port(&subs->info.sender, &c);
}
list_del(p);
......@@ -233,7 +245,7 @@ static void clear_subscriber_list(client_t *client, client_port_t *port,
kfree(subs);
} else {
/* ok we got the connected port */
port_subs_info_t *agrp;
struct snd_seq_port_subs_info *agrp;
agrp = (grptype == SRC_LIST) ? &aport->c_dest : &aport->c_src;
down_write(&agrp->list_mutex);
if (grptype == SRC_LIST)
......@@ -251,7 +263,8 @@ static void clear_subscriber_list(client_t *client, client_port_t *port,
}
/* delete port data */
static int port_delete(client_t *client, client_port_t *port)
static int port_delete(struct snd_seq_client *client,
struct snd_seq_client_port *port)
{
/* set closing flag and wait for all port access are gone */
port->closing = 1;
......@@ -273,16 +286,16 @@ static int port_delete(client_t *client, client_port_t *port)
/* delete a port with the given port id */
int snd_seq_delete_port(client_t *client, int port)
int snd_seq_delete_port(struct snd_seq_client *client, int port)
{
unsigned long flags;
struct list_head *l;
client_port_t *found = NULL;
struct snd_seq_client_port *found = NULL;
down(&client->ports_mutex);
write_lock_irqsave(&client->ports_lock, flags);
list_for_each(l, &client->ports_list_head) {
client_port_t *p = list_entry(l, client_port_t, list);
struct snd_seq_client_port *p = list_entry(l, struct snd_seq_client_port, list);
if (p->addr.port == port) {
/* ok found. delete from the list at first */
list_del(l);
......@@ -300,7 +313,7 @@ int snd_seq_delete_port(client_t *client, int port)
}
/* delete the all ports belonging to the given client */
int snd_seq_delete_all_ports(client_t *client)
int snd_seq_delete_all_ports(struct snd_seq_client *client)
{
unsigned long flags;
struct list_head deleted_list, *p, *n;
......@@ -323,7 +336,7 @@ int snd_seq_delete_all_ports(client_t *client)
/* remove each port in deleted_list */
list_for_each_safe(p, n, &deleted_list) {
client_port_t *port = list_entry(p, client_port_t, list);
struct snd_seq_client_port *port = list_entry(p, struct snd_seq_client_port, list);
list_del(p);
snd_seq_system_client_ev_port_exit(port->addr.client, port->addr.port);
port_delete(client, port);
......@@ -333,7 +346,8 @@ int snd_seq_delete_all_ports(client_t *client)
}
/* set port info fields */
int snd_seq_set_port_info(client_port_t * port, snd_seq_port_info_t * info)
int snd_seq_set_port_info(struct snd_seq_client_port * port,
struct snd_seq_port_info * info)
{
snd_assert(port && info, return -EINVAL);
......@@ -361,7 +375,8 @@ int snd_seq_set_port_info(client_port_t * port, snd_seq_port_info_t * info)
}
/* get port info fields */
int snd_seq_get_port_info(client_port_t * port, snd_seq_port_info_t * info)
int snd_seq_get_port_info(struct snd_seq_client_port * port,
struct snd_seq_port_info * info)
{
snd_assert(port && info, return -EINVAL);
......@@ -410,8 +425,11 @@ int snd_seq_get_port_info(client_port_t * port, snd_seq_port_info_t * info)
* at each connnection/disconnection.
*/
static int subscribe_port(client_t *client, client_port_t *port, port_subs_info_t *grp,
snd_seq_port_subscribe_t *info, int send_ack)
static int subscribe_port(struct snd_seq_client *client,
struct snd_seq_client_port *port,
struct snd_seq_port_subs_info *grp,
struct snd_seq_port_subscribe *info,
int send_ack)
{
int err = 0;
......@@ -432,9 +450,11 @@ static int subscribe_port(client_t *client, client_port_t *port, port_subs_info_
return err;
}
static int unsubscribe_port(client_t *client, client_port_t *port,
port_subs_info_t *grp,
snd_seq_port_subscribe_t *info, int send_ack)
static int unsubscribe_port(struct snd_seq_client *client,
struct snd_seq_client_port *port,
struct snd_seq_port_subs_info *grp,
struct snd_seq_port_subscribe *info,
int send_ack)
{
int err = 0;
......@@ -453,15 +473,15 @@ static int unsubscribe_port(client_t *client, client_port_t *port,
/* check if both addresses are identical */
static inline int addr_match(snd_seq_addr_t *r, snd_seq_addr_t *s)
static inline int addr_match(struct snd_seq_addr *r, struct snd_seq_addr *s)
{
return (r->client == s->client) && (r->port == s->port);
}
/* check the two subscribe info match */
/* if flags is zero, checks only sender and destination addresses */
static int match_subs_info(snd_seq_port_subscribe_t *r,
snd_seq_port_subscribe_t *s)
static int match_subs_info(struct snd_seq_port_subscribe *r,
struct snd_seq_port_subscribe *s)
{
if (addr_match(&r->sender, &s->sender) &&
addr_match(&r->dest, &s->dest)) {
......@@ -475,14 +495,16 @@ static int match_subs_info(snd_seq_port_subscribe_t *r,
/* connect two ports */
int snd_seq_port_connect(client_t *connector,
client_t *src_client, client_port_t *src_port,
client_t *dest_client, client_port_t *dest_port,
snd_seq_port_subscribe_t *info)
int snd_seq_port_connect(struct snd_seq_client *connector,
struct snd_seq_client *src_client,
struct snd_seq_client_port *src_port,
struct snd_seq_client *dest_client,
struct snd_seq_client_port *dest_port,
struct snd_seq_port_subscribe *info)
{
port_subs_info_t *src = &src_port->c_src;
port_subs_info_t *dest = &dest_port->c_dest;
subscribers_t *subs;
struct snd_seq_port_subs_info *src = &src_port->c_src;
struct snd_seq_port_subs_info *dest = &dest_port->c_dest;
struct snd_seq_subscribers *subs;
struct list_head *p;
int err, src_called = 0;
unsigned long flags;
......@@ -508,12 +530,12 @@ int snd_seq_port_connect(client_t *connector,
goto __error;
/* check whether already exists */
list_for_each(p, &src->list_head) {
subscribers_t *s = list_entry(p, subscribers_t, src_list);
struct snd_seq_subscribers *s = list_entry(p, struct snd_seq_subscribers, src_list);
if (match_subs_info(info, &s->info))
goto __error;
}
list_for_each(p, &dest->list_head) {
subscribers_t *s = list_entry(p, subscribers_t, dest_list);
struct snd_seq_subscribers *s = list_entry(p, struct snd_seq_subscribers, dest_list);
if (match_subs_info(info, &s->info))
goto __error;
}
......@@ -554,14 +576,16 @@ int snd_seq_port_connect(client_t *connector,
/* remove the connection */
int snd_seq_port_disconnect(client_t *connector,
client_t *src_client, client_port_t *src_port,
client_t *dest_client, client_port_t *dest_port,
snd_seq_port_subscribe_t *info)
int snd_seq_port_disconnect(struct snd_seq_client *connector,
struct snd_seq_client *src_client,
struct snd_seq_client_port *src_port,
struct snd_seq_client *dest_client,
struct snd_seq_client_port *dest_port,
struct snd_seq_port_subscribe *info)
{
port_subs_info_t *src = &src_port->c_src;
port_subs_info_t *dest = &dest_port->c_dest;
subscribers_t *subs;
struct snd_seq_port_subs_info *src = &src_port->c_src;
struct snd_seq_port_subs_info *dest = &dest_port->c_dest;
struct snd_seq_subscribers *subs;
struct list_head *p;
int err = -ENOENT;
unsigned long flags;
......@@ -571,7 +595,7 @@ int snd_seq_port_disconnect(client_t *connector,
/* look for the connection */
list_for_each(p, &src->list_head) {
subs = list_entry(p, subscribers_t, src_list);
subs = list_entry(p, struct snd_seq_subscribers, src_list);
if (match_subs_info(info, &subs->info)) {
write_lock_irqsave(&src->list_lock, flags);
// write_lock(&dest->list_lock); // no lock yet
......@@ -597,15 +621,15 @@ int snd_seq_port_disconnect(client_t *connector,
/* get matched subscriber */
subscribers_t *snd_seq_port_get_subscription(port_subs_info_t *src_grp,
snd_seq_addr_t *dest_addr)
struct snd_seq_subscribers *snd_seq_port_get_subscription(struct snd_seq_port_subs_info *src_grp,
struct snd_seq_addr *dest_addr)
{
struct list_head *p;
subscribers_t *s, *found = NULL;
struct snd_seq_subscribers *s, *found = NULL;
down_read(&src_grp->list_mutex);
list_for_each(p, &src_grp->list_head) {
s = list_entry(p, subscribers_t, src_list);
s = list_entry(p, struct snd_seq_subscribers, src_list);
if (addr_match(dest_addr, &s->info.dest)) {
found = s;
break;
......@@ -623,11 +647,11 @@ subscribers_t *snd_seq_port_get_subscription(port_subs_info_t *src_grp,
*/
/* exported */
int snd_seq_event_port_attach(int client,
snd_seq_port_callback_t *pcbp,
struct snd_seq_port_callback *pcbp,
int cap, int type, int midi_channels,
int midi_voices, char *portname)
{
snd_seq_port_info_t portinfo;
struct snd_seq_port_info portinfo;
int ret;
/* Set up the port */
......@@ -660,7 +684,7 @@ int snd_seq_event_port_attach(int client,
/* exported */
int snd_seq_event_port_detach(int client, int port)
{
snd_seq_port_info_t portinfo;
struct snd_seq_port_info portinfo;
int err;
memset(&portinfo, 0, sizeof(portinfo));
......
sound/core/seq/seq_ports.h
浏览文件 @ c7e0b5bf
......@@ -40,37 +40,38 @@
*/
typedef struct subscribers_t {
snd_seq_port_subscribe_t info; /* additional info */
struct snd_seq_subscribers {
struct snd_seq_port_subscribe info; /* additional info */
struct list_head src_list; /* link of sources */
struct list_head dest_list; /* link of destinations */
atomic_t ref_count;
} subscribers_t;
};
typedef struct port_subs_info_t {
struct snd_seq_port_subs_info {
struct list_head list_head; /* list of subscribed ports */
unsigned int count; /* count of subscribers */
unsigned int exclusive: 1; /* exclusive mode */
struct rw_semaphore list_mutex;
rwlock_t list_lock;
snd_seq_kernel_port_open_t *open;
snd_seq_kernel_port_close_t *close;
} port_subs_info_t;
int (*open)(void *private_data, struct snd_seq_port_subscribe *info);
int (*close)(void *private_data, struct snd_seq_port_subscribe *info);
};
typedef struct client_port_t {
struct snd_seq_client_port {
snd_seq_addr_t addr; /* client/port number */
struct snd_seq_addr addr; /* client/port number */
struct module *owner; /* owner of this port */
char name[64]; /* port name */
struct list_head list; /* port list */
snd_use_lock_t use_lock;
/* subscribers */
port_subs_info_t c_src; /* read (sender) list */
port_subs_info_t c_dest; /* write (dest) list */
struct snd_seq_port_subs_info c_src; /* read (sender) list */
struct snd_seq_port_subs_info c_dest; /* write (dest) list */
snd_seq_kernel_port_input_t *event_input;
snd_seq_kernel_port_private_free_t *private_free;
int (*event_input)(struct snd_seq_event *ev, int direct, void *private_data,
int atomic, int hop);
void (*private_free)(void *private_data);
void *private_data;
unsigned int callback_all : 1;
unsigned int closing : 1;
......@@ -87,42 +88,55 @@ typedef struct client_port_t {
int midi_voices;
int synth_voices;
} client_port_t;
};
struct snd_seq_client;
/* return pointer to port structure and lock port */
client_port_t *snd_seq_port_use_ptr(client_t *client, int num);
struct snd_seq_client_port *snd_seq_port_use_ptr(struct snd_seq_client *client, int num);
/* search for next port - port is locked if found */
client_port_t *snd_seq_port_query_nearest(client_t *client, snd_seq_port_info_t *pinfo);
struct snd_seq_client_port *snd_seq_port_query_nearest(struct snd_seq_client *client,
struct snd_seq_port_info *pinfo);
/* unlock the port */
#define snd_seq_port_unlock(port) snd_use_lock_free(&(port)->use_lock)
/* create a port, port number is returned (-1 on failure) */
client_port_t *snd_seq_create_port(client_t *client, int port_index);
struct snd_seq_client_port *snd_seq_create_port(struct snd_seq_client *client, int port_index);
/* delete a port */
int snd_seq_delete_port(client_t *client, int port);
int snd_seq_delete_port(struct snd_seq_client *client, int port);
/* delete all ports */
int snd_seq_delete_all_ports(client_t *client);
int snd_seq_delete_all_ports(struct snd_seq_client *client);
/* set port info fields */
int snd_seq_set_port_info(client_port_t *port, snd_seq_port_info_t *info);
int snd_seq_set_port_info(struct snd_seq_client_port *port,
struct snd_seq_port_info *info);
/* get port info fields */
int snd_seq_get_port_info(client_port_t *port, snd_seq_port_info_t *info);
int snd_seq_get_port_info(struct snd_seq_client_port *port,
struct snd_seq_port_info *info);
/* add subscriber to subscription list */
int snd_seq_port_connect(client_t *caller, client_t *s, client_port_t *sp, client_t *d, client_port_t *dp, snd_seq_port_subscribe_t *info);
int snd_seq_port_connect(struct snd_seq_client *caller,
struct snd_seq_client *s, struct snd_seq_client_port *sp,
struct snd_seq_client *d, struct snd_seq_client_port *dp,
struct snd_seq_port_subscribe *info);
/* remove subscriber from subscription list */
int snd_seq_port_disconnect(client_t *caller, client_t *s, client_port_t *sp, client_t *d, client_port_t *dp, snd_seq_port_subscribe_t *info);
int snd_seq_port_disconnect(struct snd_seq_client *caller,
struct snd_seq_client *s, struct snd_seq_client_port *sp,
struct snd_seq_client *d, struct snd_seq_client_port *dp,
struct snd_seq_port_subscribe *info);
/* subscribe port */
int snd_seq_port_subscribe(client_port_t *port, snd_seq_port_subscribe_t *info);
int snd_seq_port_subscribe(struct snd_seq_client_port *port,
struct snd_seq_port_subscribe *info);
/* get matched subscriber */
subscribers_t *snd_seq_port_get_subscription(port_subs_info_t *src_grp, snd_seq_addr_t *dest_addr);
struct snd_seq_subscribers *snd_seq_port_get_subscription(struct snd_seq_port_subs_info *src_grp,
struct snd_seq_addr *dest_addr);
#endif
sound/core/seq/seq_prioq.c
浏览文件 @ c7e0b5bf
此差异已折叠。
sound/core/seq/seq_prioq.h
浏览文件 @ c7e0b5bf
......@@ -26,37 +26,37 @@
/* === PRIOQ === */
typedef struct {
snd_seq_event_cell_t* head; /* pointer to head of prioq */
snd_seq_event_cell_t* tail; /* pointer to tail of prioq */
struct snd_seq_prioq {
struct snd_seq_event_cell *head; /* pointer to head of prioq */
struct snd_seq_event_cell *tail; /* pointer to tail of prioq */
int cells;
spinlock_t lock;
} prioq_t;
};
/* create new prioq (constructor) */
extern prioq_t *snd_seq_prioq_new(void);
struct snd_seq_prioq *snd_seq_prioq_new(void);
/* delete prioq (destructor) */
extern void snd_seq_prioq_delete(prioq_t **fifo);
void snd_seq_prioq_delete(struct snd_seq_prioq **fifo);
/* enqueue cell to prioq */
extern int snd_seq_prioq_cell_in(prioq_t *f, snd_seq_event_cell_t *cell);
int snd_seq_prioq_cell_in(struct snd_seq_prioq *f, struct snd_seq_event_cell *cell);
/* dequeue cell from prioq */
extern snd_seq_event_cell_t *snd_seq_prioq_cell_out(prioq_t *f);
struct snd_seq_event_cell *snd_seq_prioq_cell_out(struct snd_seq_prioq *f);
/* return number of events available in prioq */
extern int snd_seq_prioq_avail(prioq_t *f);
int snd_seq_prioq_avail(struct snd_seq_prioq *f);
/* peek at cell at the head of the prioq */
extern snd_seq_event_cell_t *snd_seq_prioq_cell_peek(prioq_t *f);
struct snd_seq_event_cell *snd_seq_prioq_cell_peek(struct snd_seq_prioq *f);
/* client left queue */
extern void snd_seq_prioq_leave(prioq_t *f, int client, int timestamp);
void snd_seq_prioq_leave(struct snd_seq_prioq *f, int client, int timestamp);
/* Remove events */
void snd_seq_prioq_remove_events(prioq_t * f, int client,
snd_seq_remove_events_t *info);
void snd_seq_prioq_remove_events(struct snd_seq_prioq *f, int client,
struct snd_seq_remove_events *info);
#endif
sound/core/seq/seq_queue.c
浏览文件 @ c7e0b5bf
此差异已折叠。
sound/core/seq/seq_queue.h
浏览文件 @ c7e0b5bf
此差异已折叠。
sound/core/seq/seq_system.c
浏览文件 @ c7e0b5bf
......@@ -66,12 +66,12 @@ static int announce_port = -1;
/* fill standard header data, source port & channel are filled in */
static int setheader(snd_seq_event_t * ev, int client, int port)
static int setheader(struct snd_seq_event * ev, int client, int port)
{
if (announce_port < 0)
return -ENODEV;
memset(ev, 0, sizeof(snd_seq_event_t));
memset(ev, 0, sizeof(struct snd_seq_event));
ev->flags &= ~SNDRV_SEQ_EVENT_LENGTH_MASK;
ev->flags |= SNDRV_SEQ_EVENT_LENGTH_FIXED;
......@@ -92,7 +92,7 @@ static int setheader(snd_seq_event_t * ev, int client, int port)
/* entry points for broadcasting system events */
void snd_seq_system_broadcast(int client, int port, int type)
{
snd_seq_event_t ev;
struct snd_seq_event ev;
if (setheader(&ev, client, port) < 0)
return;
......@@ -101,7 +101,7 @@ void snd_seq_system_broadcast(int client, int port, int type)
}
/* entry points for broadcasting system events */
int snd_seq_system_notify(int client, int port, snd_seq_event_t *ev)
int snd_seq_system_notify(int client, int port, struct snd_seq_event *ev)
{
ev->flags = SNDRV_SEQ_EVENT_LENGTH_FIXED;
ev->source.client = sysclient;
......@@ -112,7 +112,7 @@ int snd_seq_system_notify(int client, int port, snd_seq_event_t *ev)
}
/* call-back handler for timer events */
static int event_input_timer(snd_seq_event_t * ev, int direct, void *private_data, int atomic, int hop)
static int event_input_timer(struct snd_seq_event * ev, int direct, void *private_data, int atomic, int hop)
{
return snd_seq_control_queue(ev, atomic, hop);
}
......@@ -121,10 +121,10 @@ static int event_input_timer(snd_seq_event_t * ev, int direct, void *private_dat
int __init snd_seq_system_client_init(void)
{
snd_seq_client_callback_t callbacks;
snd_seq_port_callback_t pcallbacks;
snd_seq_client_info_t *inf;
snd_seq_port_info_t *port;
struct snd_seq_client_callback callbacks;
struct snd_seq_port_callback pcallbacks;
struct snd_seq_client_info *inf;
struct snd_seq_port_info *port;
inf = kzalloc(sizeof(*inf), GFP_KERNEL);
port = kzalloc(sizeof(*port), GFP_KERNEL);
......
sound/core/seq/seq_system.h
浏览文件 @ c7e0b5bf
此差异已折叠。
sound/core/seq/seq_timer.c
浏览文件 @ c7e0b5bf
此差异已折叠。
sound/core/seq/seq_timer.h
浏览文件 @ c7e0b5bf
此差异已折叠。
sound/core/seq/seq_virmidi.c
浏览文件 @ c7e0b5bf
此差异已折叠。
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或