korg/linux
0
0
Fork 0
mirror of https://mirrors.bfsu.edu.cn/git/linux.git synced 2024-11-28 14:44:10 +08:00
Code Issues Packages Projects Releases Wiki Activity

[ALSA] seq: remove struct snd_seq_client_callback

Browse Source 
The fields of struct snd_seq_client_callback either aren't used or are
always set to the same value, so we can get rid of it altogether.

Signed-off-by: Clemens Ladisch <clemens@ladisch.de>
This commit is contained in:
Clemens Ladisch 2005-12-12 09:30:43 +01:00 committed by Jaroslav Kysela
parent 255bd169ab
commit 83e8ad6984
13 changed files with 14 additions and 75 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
include/sound/seq_kernel.h
View File

@ -60,15 +60,6 @@ typedef union snd_seq_timestamp snd_seq_timestamp_t;
/* max size of event size */
#define SNDRV_SEQ_MAX_EVENT_LEN 0x3fffffff
/* call-backs for kernel client */
struct snd_seq_client_callback {
void *private_data;
unsigned allow_input: 1,
allow_output: 1;
/*...*/
};
/* call-backs for kernel port */
struct snd_seq_port_callback {
struct module *owner;
@ -84,8 +75,7 @@ struct snd_seq_port_callback {
};
/* interface for kernel client */
int snd_seq_create_kernel_client(struct snd_card *card, int client_index,
struct snd_seq_client_callback *callback);
int snd_seq_create_kernel_client(struct snd_card *card, int client_index);
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);

9
sound/core/seq/oss/seq_oss_init.c
View File

@ -65,7 +65,6 @@ int __init
snd_seq_oss_create_client(void)
{
int rc;
struct snd_seq_client_callback callback;
struct snd_seq_client_info *info;
struct snd_seq_port_info *port;
struct snd_seq_port_callback port_callback;
@ -78,13 +77,7 @@ snd_seq_oss_create_client(void)
}
/* create ALSA client */
memset(&callback, 0, sizeof(callback));
callback.private_data = NULL;
callback.allow_input = 1;
callback.allow_output = 1;
rc = snd_seq_create_kernel_client(NULL, SNDRV_SEQ_CLIENT_OSS, &callback);
rc = snd_seq_create_kernel_client(NULL, SNDRV_SEQ_CLIENT_OSS);
if (rc < 0)
goto __error;

9
sound/core/seq/seq_clientmgr.c
View File

@ -2212,15 +2212,12 @@ static long snd_seq_ioctl(struct file *file, unsigned int cmd, unsigned long arg
/* exported to kernel modules */
int snd_seq_create_kernel_client(struct snd_card *card, int client_index,
struct snd_seq_client_callback *callback)
int snd_seq_create_kernel_client(struct snd_card *card, int client_index)
{
struct snd_seq_client *client;
snd_assert(! in_interrupt(), return -EBUSY);
if (callback == NULL)
return -EINVAL;
if (card && client_index > 3)
return -EINVAL;
if (card == NULL && client_index > 63)
@ -2244,8 +2241,8 @@ int snd_seq_create_kernel_client(struct snd_card *card, int client_index,
}
usage_alloc(&client_usage, 1);
client->accept_input = callback->allow_output;
client->accept_output = callback->allow_input;
client->accept_input = 1;
client->accept_output = 1;
sprintf(client->name, "Client-%d", client->number);

2
sound/core/seq/seq_clientmgr.h
View File

@ -91,8 +91,6 @@ struct snd_seq_client *snd_seq_client_use_ptr(int clientid);
int snd_seq_dispatch_event(struct snd_seq_event_cell *cell, int atomic, int hop);
/* exported to other modules */
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);

6
sound/core/seq/seq_dummy.c
View File

@ -193,7 +193,6 @@ create_port(int idx, int type)
static int __init
register_client(void)
{
struct snd_seq_client_callback cb;
struct snd_seq_client_info cinfo;
struct snd_seq_dummy_port *rec1, *rec2;
int i;
@ -204,10 +203,7 @@ register_client(void)
}
/* create client */
memset(&cb, 0, sizeof(cb));
cb.allow_input = 1;
cb.allow_output = 1;
my_client = snd_seq_create_kernel_client(NULL, SNDRV_SEQ_CLIENT_DUMMY, &cb);
my_client = snd_seq_create_kernel_client(NULL, SNDRV_SEQ_CLIENT_DUMMY);
if (my_client < 0)
return my_client;

6
sound/core/seq/seq_midi.c
View File

@ -295,7 +295,6 @@ snd_seq_midisynth_register_port(struct snd_seq_device *dev)
struct snd_rawmidi_info *info;
int newclient = 0;
unsigned int p, ports;
struct snd_seq_client_callback callbacks;
struct snd_seq_port_callback pcallbacks;
struct snd_card *card = dev->card;
int device = dev->device;
@ -334,10 +333,7 @@ snd_seq_midisynth_register_port(struct snd_seq_device *dev)
kfree(info);
return -ENOMEM;
}
memset(&callbacks, 0, sizeof(callbacks));
callbacks.private_data = client;
callbacks.allow_input = callbacks.allow_output = 1;
client->seq_client = snd_seq_create_kernel_client(card, 0, &callbacks);
client->seq_client = snd_seq_create_kernel_client(card, 0);
if (client->seq_client < 0) {
kfree(client);
up(&register_mutex);

6
sound/core/seq/seq_system.c
View File

@ -120,8 +120,6 @@ static int event_input_timer(struct snd_seq_event * ev, int direct, void *privat
/* register our internal client */
int __init snd_seq_system_client_init(void)
{
struct snd_seq_client_callback callbacks;
struct snd_seq_port_callback pcallbacks;
struct snd_seq_client_info *inf;
struct snd_seq_port_info *port;
@ -134,14 +132,12 @@ int __init snd_seq_system_client_init(void)
return -ENOMEM;
}
memset(&callbacks, 0, sizeof(callbacks));
memset(&pcallbacks, 0, sizeof(pcallbacks));
pcallbacks.owner = THIS_MODULE;
pcallbacks.event_input = event_input_timer;
/* register client */
callbacks.allow_input = callbacks.allow_output = 1;
sysclient = snd_seq_create_kernel_client(NULL, 0, &callbacks);
sysclient = snd_seq_create_kernel_client(NULL, 0);
/* set our name */
inf->client = 0;

7
sound/core/seq/seq_virmidi.c
View File

@ -359,7 +359,6 @@ static struct snd_rawmidi_ops snd_virmidi_output_ops = {
static int snd_virmidi_dev_attach_seq(struct snd_virmidi_dev *rdev)
{
int client;
struct snd_seq_client_callback callbacks;
struct snd_seq_port_callback pcallbacks;
struct snd_seq_client_info *info;
struct snd_seq_port_info *pinfo;
@ -375,11 +374,7 @@ static int snd_virmidi_dev_attach_seq(struct snd_virmidi_dev *rdev)
goto __error;
}
memset(&callbacks, 0, sizeof(callbacks));
callbacks.private_data = rdev;
callbacks.allow_input = 1;
callbacks.allow_output = 1;
client = snd_seq_create_kernel_client(rdev->card, rdev->device, &callbacks);
client = snd_seq_create_kernel_client(rdev->card, rdev->device);
if (client < 0) {
err = client;
goto __error;

6
sound/drivers/opl3/opl3_seq.c
View File

@ -219,7 +219,6 @@ static int snd_opl3_seq_new_device(struct snd_seq_device *dev)
{
struct snd_opl3 *opl3;
int client;
struct snd_seq_client_callback callbacks;
struct snd_seq_client_info cinfo;
int opl_ver;
@ -232,11 +231,8 @@ static int snd_opl3_seq_new_device(struct snd_seq_device *dev)
opl3->seq_client = -1;
/* allocate new client */
memset(&callbacks, 0, sizeof(callbacks));
callbacks.private_data = opl3;
callbacks.allow_output = callbacks.allow_input = 1;
client = opl3->seq_client =
snd_seq_create_kernel_client(opl3->card, opl3->seq_dev_num, &callbacks);
snd_seq_create_kernel_client(opl3->card, opl3->seq_dev_num);
if (client < 0)
return client;

6
sound/drivers/opl4/opl4_seq.c
View File

@ -127,7 +127,6 @@ static int snd_opl4_seq_new_device(struct snd_seq_device *dev)
{
struct snd_opl4 *opl4;
int client;
struct snd_seq_client_callback callbacks;
struct snd_seq_client_info cinfo;
struct snd_seq_port_callback pcallbacks;
@ -144,10 +143,7 @@ static int snd_opl4_seq_new_device(struct snd_seq_device *dev)
opl4->chset->private_data = opl4;
/* allocate new client */
memset(&callbacks, 0, sizeof(callbacks));
callbacks.private_data = opl4;
callbacks.allow_output = callbacks.allow_input = 1;
client = snd_seq_create_kernel_client(opl4->card, opl4->seq_dev_num, &callbacks);
client = snd_seq_create_kernel_client(opl4->card, opl4->seq_dev_num);
if (client < 0) {
snd_midi_channel_free_set(opl4->chset);
return client;

6
sound/isa/gus/gus_synth.c
View File

@ -214,7 +214,6 @@ static int snd_gus_synth_new_device(struct snd_seq_device *dev)
{
struct snd_gus_card *gus;
int client, i;
struct snd_seq_client_callback callbacks;
struct snd_seq_client_info *cinfo;
struct snd_seq_port_subscribe sub;
struct snd_iwffff_ops *iwops;
@ -233,11 +232,8 @@ static int snd_gus_synth_new_device(struct snd_seq_device *dev)
return -ENOMEM;
/* allocate new client */
memset(&callbacks, 0, sizeof(callbacks));
callbacks.private_data = gus;
callbacks.allow_output = callbacks.allow_input = 1;
client = gus->gf1.seq_client =
snd_seq_create_kernel_client(gus->card, 1, &callbacks);
snd_seq_create_kernel_client(gus->card, 1);
if (client < 0) {
kfree(cinfo);
return client;

6
sound/pci/trident/trident_synth.c
View File

@ -934,7 +934,6 @@ static int snd_trident_synth_new_device(struct snd_seq_device *dev)
{
struct snd_trident *trident;
int client, i;
struct snd_seq_client_callback callbacks;
struct snd_seq_client_info cinfo;
struct snd_seq_port_subscribe sub;
struct snd_simple_ops *simpleops;
@ -947,11 +946,8 @@ static int snd_trident_synth_new_device(struct snd_seq_device *dev)
trident->synth.seq_client = -1;
/* allocate new client */
memset(&callbacks, 0, sizeof(callbacks));
callbacks.private_data = trident;
callbacks.allow_output = callbacks.allow_input = 1;
client = trident->synth.seq_client =
snd_seq_create_kernel_client(trident->card, 1, &callbacks);
snd_seq_create_kernel_client(trident->card, 1);
if (client < 0)
return client;

8
sound/synth/emux/emux_seq.c
View File

@ -347,17 +347,11 @@ snd_emux_unuse(void *private_data, struct snd_seq_port_subscribe *info)
static int
get_client(struct snd_card *card, int index, char *name)
{
struct snd_seq_client_callback callbacks;
struct snd_seq_client_info cinfo;
int client;
memset(&callbacks, 0, sizeof(callbacks));
callbacks.private_data = NULL;
callbacks.allow_input = 1;
callbacks.allow_output = 1;
/* Find a free client, start from 1 as the MPU expects to use 0 */
client = snd_seq_create_kernel_client(card, index, &callbacks);
client = snd_seq_create_kernel_client(card, index);
if (client < 0)
return client;