From f956b4a3ae790e1bdde865ac42dd1b99b64a6256 Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Thu, 17 Nov 2005 14:01:22 +0100 Subject: [ALSA] Remove xxx_t typedefs: Mixer OSS-emulation Modules: ALSA<-OSS emulation Remove xxx_t typedefs from the core mixer OSS-emulation codes. Signed-off-by: Takashi Iwai --- sound/core/oss/mixer_oss.c | 240 ++++++++++++++++++++++----------------------- 1 file changed, 120 insertions(+), 120 deletions(-) (limited to 'sound/core/oss/mixer_oss.c') diff --git a/sound/core/oss/mixer_oss.c b/sound/core/oss/mixer_oss.c index 214933cf5d49..e448002ca7b9 100644 --- a/sound/core/oss/mixer_oss.c +++ b/sound/core/oss/mixer_oss.c @@ -42,8 +42,8 @@ MODULE_ALIAS_SNDRV_MINOR(SNDRV_MINOR_OSS_MIXER); static int snd_mixer_oss_open(struct inode *inode, struct file *file) { int cardnum = SNDRV_MINOR_OSS_CARD(iminor(inode)); - snd_card_t *card; - snd_mixer_oss_file_t *fmixer; + struct snd_card *card; + struct snd_mixer_oss_file *fmixer; int err; if ((card = snd_cards[cardnum]) == NULL) @@ -71,10 +71,10 @@ static int snd_mixer_oss_open(struct inode *inode, struct file *file) static int snd_mixer_oss_release(struct inode *inode, struct file *file) { - snd_mixer_oss_file_t *fmixer; + struct snd_mixer_oss_file *fmixer; if (file->private_data) { - fmixer = (snd_mixer_oss_file_t *) file->private_data; + fmixer = (struct snd_mixer_oss_file *) file->private_data; module_put(fmixer->card->module); snd_card_file_remove(fmixer->card, file); kfree(fmixer); @@ -82,11 +82,11 @@ static int snd_mixer_oss_release(struct inode *inode, struct file *file) return 0; } -static int snd_mixer_oss_info(snd_mixer_oss_file_t *fmixer, +static int snd_mixer_oss_info(struct snd_mixer_oss_file *fmixer, mixer_info __user *_info) { - snd_card_t *card = fmixer->card; - snd_mixer_oss_t *mixer = fmixer->mixer; + struct snd_card *card = fmixer->card; + struct snd_mixer_oss *mixer = fmixer->mixer; struct mixer_info info; memset(&info, 0, sizeof(info)); @@ -98,11 +98,11 @@ static int snd_mixer_oss_info(snd_mixer_oss_file_t *fmixer, return 0; } -static int snd_mixer_oss_info_obsolete(snd_mixer_oss_file_t *fmixer, +static int snd_mixer_oss_info_obsolete(struct snd_mixer_oss_file *fmixer, _old_mixer_info __user *_info) { - snd_card_t *card = fmixer->card; - snd_mixer_oss_t *mixer = fmixer->mixer; + struct snd_card *card = fmixer->card; + struct snd_mixer_oss *mixer = fmixer->mixer; _old_mixer_info info; memset(&info, 0, sizeof(info)); @@ -113,9 +113,9 @@ static int snd_mixer_oss_info_obsolete(snd_mixer_oss_file_t *fmixer, return 0; } -static int snd_mixer_oss_caps(snd_mixer_oss_file_t *fmixer) +static int snd_mixer_oss_caps(struct snd_mixer_oss_file *fmixer) { - snd_mixer_oss_t *mixer = fmixer->mixer; + struct snd_mixer_oss *mixer = fmixer->mixer; int result = 0; if (mixer == NULL) @@ -125,10 +125,10 @@ static int snd_mixer_oss_caps(snd_mixer_oss_file_t *fmixer) return result; } -static int snd_mixer_oss_devmask(snd_mixer_oss_file_t *fmixer) +static int snd_mixer_oss_devmask(struct snd_mixer_oss_file *fmixer) { - snd_mixer_oss_t *mixer = fmixer->mixer; - snd_mixer_oss_slot_t *pslot; + struct snd_mixer_oss *mixer = fmixer->mixer; + struct snd_mixer_oss_slot *pslot; int result = 0, chn; if (mixer == NULL) @@ -141,10 +141,10 @@ static int snd_mixer_oss_devmask(snd_mixer_oss_file_t *fmixer) return result; } -static int snd_mixer_oss_stereodevs(snd_mixer_oss_file_t *fmixer) +static int snd_mixer_oss_stereodevs(struct snd_mixer_oss_file *fmixer) { - snd_mixer_oss_t *mixer = fmixer->mixer; - snd_mixer_oss_slot_t *pslot; + struct snd_mixer_oss *mixer = fmixer->mixer; + struct snd_mixer_oss_slot *pslot; int result = 0, chn; if (mixer == NULL) @@ -157,9 +157,9 @@ static int snd_mixer_oss_stereodevs(snd_mixer_oss_file_t *fmixer) return result; } -static int snd_mixer_oss_recmask(snd_mixer_oss_file_t *fmixer) +static int snd_mixer_oss_recmask(struct snd_mixer_oss_file *fmixer) { - snd_mixer_oss_t *mixer = fmixer->mixer; + struct snd_mixer_oss *mixer = fmixer->mixer; int result = 0; if (mixer == NULL) @@ -167,7 +167,7 @@ static int snd_mixer_oss_recmask(snd_mixer_oss_file_t *fmixer) if (mixer->put_recsrc && mixer->get_recsrc) { /* exclusive */ result = mixer->mask_recsrc; } else { - snd_mixer_oss_slot_t *pslot; + struct snd_mixer_oss_slot *pslot; int chn; for (chn = 0; chn < 31; chn++) { pslot = &mixer->slots[chn]; @@ -178,9 +178,9 @@ static int snd_mixer_oss_recmask(snd_mixer_oss_file_t *fmixer) return result; } -static int snd_mixer_oss_get_recsrc(snd_mixer_oss_file_t *fmixer) +static int snd_mixer_oss_get_recsrc(struct snd_mixer_oss_file *fmixer) { - snd_mixer_oss_t *mixer = fmixer->mixer; + struct snd_mixer_oss *mixer = fmixer->mixer; int result = 0; if (mixer == NULL) @@ -191,7 +191,7 @@ static int snd_mixer_oss_get_recsrc(snd_mixer_oss_file_t *fmixer) return err; result = 1 << result; } else { - snd_mixer_oss_slot_t *pslot; + struct snd_mixer_oss_slot *pslot; int chn; for (chn = 0; chn < 31; chn++) { pslot = &mixer->slots[chn]; @@ -206,10 +206,10 @@ static int snd_mixer_oss_get_recsrc(snd_mixer_oss_file_t *fmixer) return mixer->oss_recsrc = result; } -static int snd_mixer_oss_set_recsrc(snd_mixer_oss_file_t *fmixer, int recsrc) +static int snd_mixer_oss_set_recsrc(struct snd_mixer_oss_file *fmixer, int recsrc) { - snd_mixer_oss_t *mixer = fmixer->mixer; - snd_mixer_oss_slot_t *pslot; + struct snd_mixer_oss *mixer = fmixer->mixer; + struct snd_mixer_oss_slot *pslot; int chn, active; int result = 0; @@ -243,10 +243,10 @@ static int snd_mixer_oss_set_recsrc(snd_mixer_oss_file_t *fmixer, int recsrc) return result; } -static int snd_mixer_oss_get_volume(snd_mixer_oss_file_t *fmixer, int slot) +static int snd_mixer_oss_get_volume(struct snd_mixer_oss_file *fmixer, int slot) { - snd_mixer_oss_t *mixer = fmixer->mixer; - snd_mixer_oss_slot_t *pslot; + struct snd_mixer_oss *mixer = fmixer->mixer; + struct snd_mixer_oss_slot *pslot; int result = 0, left, right; if (mixer == NULL || slot > 30) @@ -268,11 +268,11 @@ static int snd_mixer_oss_get_volume(snd_mixer_oss_file_t *fmixer, int slot) return result; } -static int snd_mixer_oss_set_volume(snd_mixer_oss_file_t *fmixer, +static int snd_mixer_oss_set_volume(struct snd_mixer_oss_file *fmixer, int slot, int volume) { - snd_mixer_oss_t *mixer = fmixer->mixer; - snd_mixer_oss_slot_t *pslot; + struct snd_mixer_oss *mixer = fmixer->mixer; + struct snd_mixer_oss_slot *pslot; int result = 0, left = volume & 0xff, right = (volume >> 8) & 0xff; if (mixer == NULL || slot > 30) @@ -293,7 +293,7 @@ static int snd_mixer_oss_set_volume(snd_mixer_oss_file_t *fmixer, return (left & 0xff) | ((right & 0xff) << 8); } -static int snd_mixer_oss_ioctl1(snd_mixer_oss_file_t *fmixer, unsigned int cmd, unsigned long arg) +static int snd_mixer_oss_ioctl1(struct snd_mixer_oss_file *fmixer, unsigned int cmd, unsigned long arg) { void __user *argp = (void __user *)arg; int __user *p = argp; @@ -362,12 +362,12 @@ static int snd_mixer_oss_ioctl1(snd_mixer_oss_file_t *fmixer, unsigned int cmd, static long snd_mixer_oss_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { - return snd_mixer_oss_ioctl1((snd_mixer_oss_file_t *) file->private_data, cmd, arg); + return snd_mixer_oss_ioctl1((struct snd_mixer_oss_file *) file->private_data, cmd, arg); } -int snd_mixer_oss_ioctl_card(snd_card_t *card, unsigned int cmd, unsigned long arg) +int snd_mixer_oss_ioctl_card(struct snd_card *card, unsigned int cmd, unsigned long arg) { - snd_mixer_oss_file_t fmixer; + struct snd_mixer_oss_file fmixer; snd_assert(card != NULL, return -ENXIO); if (card->mixer_oss == NULL) @@ -398,7 +398,7 @@ static struct file_operations snd_mixer_oss_f_ops = .compat_ioctl = snd_mixer_oss_ioctl_compat, }; -static snd_minor_t snd_mixer_oss_reg = +static struct snd_minor snd_mixer_oss_reg = { .comment = "mixer", .f_ops = &snd_mixer_oss_f_ops, @@ -432,16 +432,16 @@ static long snd_mixer_oss_conv2(long val, long min, long max) } #if 0 -static void snd_mixer_oss_recsrce_set(snd_card_t *card, int slot) +static void snd_mixer_oss_recsrce_set(struct snd_card *card, int slot) { - snd_mixer_oss_t *mixer = card->mixer_oss; + struct snd_mixer_oss *mixer = card->mixer_oss; if (mixer) mixer->mask_recsrc |= 1 << slot; } -static int snd_mixer_oss_recsrce_get(snd_card_t *card, int slot) +static int snd_mixer_oss_recsrce_get(struct snd_card *card, int slot) { - snd_mixer_oss_t *mixer = card->mixer_oss; + struct snd_mixer_oss *mixer = card->mixer_oss; if (mixer && (mixer->mask_recsrc & (1 << slot))) return 1; return 0; @@ -488,10 +488,10 @@ struct slot { #define ID_UNKNOWN ((unsigned int)-1) -static snd_kcontrol_t *snd_mixer_oss_test_id(snd_mixer_oss_t *mixer, const char *name, int index) +static struct snd_kcontrol *snd_mixer_oss_test_id(struct snd_mixer_oss *mixer, const char *name, int index) { - snd_card_t * card = mixer->card; - snd_ctl_elem_id_t id; + struct snd_card *card = mixer->card; + struct snd_ctl_elem_id id; memset(&id, 0, sizeof(id)); id.iface = SNDRV_CTL_ELEM_IFACE_MIXER; @@ -500,15 +500,15 @@ static snd_kcontrol_t *snd_mixer_oss_test_id(snd_mixer_oss_t *mixer, const char return snd_ctl_find_id(card, &id); } -static void snd_mixer_oss_get_volume1_vol(snd_mixer_oss_file_t *fmixer, - snd_mixer_oss_slot_t *pslot, +static void snd_mixer_oss_get_volume1_vol(struct snd_mixer_oss_file *fmixer, + struct snd_mixer_oss_slot *pslot, unsigned int numid, int *left, int *right) { - snd_ctl_elem_info_t *uinfo; - snd_ctl_elem_value_t *uctl; - snd_kcontrol_t *kctl; - snd_card_t *card = fmixer->card; + struct snd_ctl_elem_info *uinfo; + struct snd_ctl_elem_value *uctl; + struct snd_kcontrol *kctl; + struct snd_card *card = fmixer->card; if (numid == ID_UNKNOWN) return; @@ -537,16 +537,16 @@ static void snd_mixer_oss_get_volume1_vol(snd_mixer_oss_file_t *fmixer, kfree(uinfo); } -static void snd_mixer_oss_get_volume1_sw(snd_mixer_oss_file_t *fmixer, - snd_mixer_oss_slot_t *pslot, +static void snd_mixer_oss_get_volume1_sw(struct snd_mixer_oss_file *fmixer, + struct snd_mixer_oss_slot *pslot, unsigned int numid, int *left, int *right, int route) { - snd_ctl_elem_info_t *uinfo; - snd_ctl_elem_value_t *uctl; - snd_kcontrol_t *kctl; - snd_card_t *card = fmixer->card; + struct snd_ctl_elem_info *uinfo; + struct snd_ctl_elem_value *uctl; + struct snd_kcontrol *kctl; + struct snd_card *card = fmixer->card; if (numid == ID_UNKNOWN) return; @@ -576,8 +576,8 @@ static void snd_mixer_oss_get_volume1_sw(snd_mixer_oss_file_t *fmixer, kfree(uinfo); } -static int snd_mixer_oss_get_volume1(snd_mixer_oss_file_t *fmixer, - snd_mixer_oss_slot_t *pslot, +static int snd_mixer_oss_get_volume1(struct snd_mixer_oss_file *fmixer, + struct snd_mixer_oss_slot *pslot, int *left, int *right) { struct slot *slot = (struct slot *)pslot->private_data; @@ -602,15 +602,15 @@ static int snd_mixer_oss_get_volume1(snd_mixer_oss_file_t *fmixer, return 0; } -static void snd_mixer_oss_put_volume1_vol(snd_mixer_oss_file_t *fmixer, - snd_mixer_oss_slot_t *pslot, +static void snd_mixer_oss_put_volume1_vol(struct snd_mixer_oss_file *fmixer, + struct snd_mixer_oss_slot *pslot, unsigned int numid, int left, int right) { - snd_ctl_elem_info_t *uinfo; - snd_ctl_elem_value_t *uctl; - snd_kcontrol_t *kctl; - snd_card_t *card = fmixer->card; + struct snd_ctl_elem_info *uinfo; + struct snd_ctl_elem_value *uctl; + struct snd_kcontrol *kctl; + struct snd_card *card = fmixer->card; int res; if (numid == ID_UNKNOWN) @@ -640,16 +640,16 @@ static void snd_mixer_oss_put_volume1_vol(snd_mixer_oss_file_t *fmixer, kfree(uinfo); } -static void snd_mixer_oss_put_volume1_sw(snd_mixer_oss_file_t *fmixer, - snd_mixer_oss_slot_t *pslot, +static void snd_mixer_oss_put_volume1_sw(struct snd_mixer_oss_file *fmixer, + struct snd_mixer_oss_slot *pslot, unsigned int numid, int left, int right, int route) { - snd_ctl_elem_info_t *uinfo; - snd_ctl_elem_value_t *uctl; - snd_kcontrol_t *kctl; - snd_card_t *card = fmixer->card; + struct snd_ctl_elem_info *uinfo; + struct snd_ctl_elem_value *uctl; + struct snd_kcontrol *kctl; + struct snd_card *card = fmixer->card; int res; if (numid == ID_UNKNOWN) @@ -685,8 +685,8 @@ static void snd_mixer_oss_put_volume1_sw(snd_mixer_oss_file_t *fmixer, kfree(uinfo); } -static int snd_mixer_oss_put_volume1(snd_mixer_oss_file_t *fmixer, - snd_mixer_oss_slot_t *pslot, +static int snd_mixer_oss_put_volume1(struct snd_mixer_oss_file *fmixer, + struct snd_mixer_oss_slot *pslot, int left, int right) { struct slot *slot = (struct slot *)pslot->private_data; @@ -723,8 +723,8 @@ static int snd_mixer_oss_put_volume1(snd_mixer_oss_file_t *fmixer, return 0; } -static int snd_mixer_oss_get_recsrc1_sw(snd_mixer_oss_file_t *fmixer, - snd_mixer_oss_slot_t *pslot, +static int snd_mixer_oss_get_recsrc1_sw(struct snd_mixer_oss_file *fmixer, + struct snd_mixer_oss_slot *pslot, int *active) { struct slot *slot = (struct slot *)pslot->private_data; @@ -736,8 +736,8 @@ static int snd_mixer_oss_get_recsrc1_sw(snd_mixer_oss_file_t *fmixer, return 0; } -static int snd_mixer_oss_get_recsrc1_route(snd_mixer_oss_file_t *fmixer, - snd_mixer_oss_slot_t *pslot, +static int snd_mixer_oss_get_recsrc1_route(struct snd_mixer_oss_file *fmixer, + struct snd_mixer_oss_slot *pslot, int *active) { struct slot *slot = (struct slot *)pslot->private_data; @@ -749,8 +749,8 @@ static int snd_mixer_oss_get_recsrc1_route(snd_mixer_oss_file_t *fmixer, return 0; } -static int snd_mixer_oss_put_recsrc1_sw(snd_mixer_oss_file_t *fmixer, - snd_mixer_oss_slot_t *pslot, +static int snd_mixer_oss_put_recsrc1_sw(struct snd_mixer_oss_file *fmixer, + struct snd_mixer_oss_slot *pslot, int active) { struct slot *slot = (struct slot *)pslot->private_data; @@ -759,8 +759,8 @@ static int snd_mixer_oss_put_recsrc1_sw(snd_mixer_oss_file_t *fmixer, return 0; } -static int snd_mixer_oss_put_recsrc1_route(snd_mixer_oss_file_t *fmixer, - snd_mixer_oss_slot_t *pslot, +static int snd_mixer_oss_put_recsrc1_route(struct snd_mixer_oss_file *fmixer, + struct snd_mixer_oss_slot *pslot, int active) { struct slot *slot = (struct slot *)pslot->private_data; @@ -769,15 +769,15 @@ static int snd_mixer_oss_put_recsrc1_route(snd_mixer_oss_file_t *fmixer, return 0; } -static int snd_mixer_oss_get_recsrc2(snd_mixer_oss_file_t *fmixer, unsigned int *active_index) +static int snd_mixer_oss_get_recsrc2(struct snd_mixer_oss_file *fmixer, unsigned int *active_index) { - snd_card_t *card = fmixer->card; - snd_mixer_oss_t *mixer = fmixer->mixer; - snd_kcontrol_t *kctl; - snd_mixer_oss_slot_t *pslot; + struct snd_card *card = fmixer->card; + struct snd_mixer_oss *mixer = fmixer->mixer; + struct snd_kcontrol *kctl; + struct snd_mixer_oss_slot *pslot; struct slot *slot; - snd_ctl_elem_info_t *uinfo; - snd_ctl_elem_value_t *uctl; + struct snd_ctl_elem_info *uinfo; + struct snd_ctl_elem_value *uctl; int err, idx; uinfo = kzalloc(sizeof(*uinfo), GFP_KERNEL); @@ -818,15 +818,15 @@ static int snd_mixer_oss_get_recsrc2(snd_mixer_oss_file_t *fmixer, unsigned int return err; } -static int snd_mixer_oss_put_recsrc2(snd_mixer_oss_file_t *fmixer, unsigned int active_index) +static int snd_mixer_oss_put_recsrc2(struct snd_mixer_oss_file *fmixer, unsigned int active_index) { - snd_card_t *card = fmixer->card; - snd_mixer_oss_t *mixer = fmixer->mixer; - snd_kcontrol_t *kctl; - snd_mixer_oss_slot_t *pslot; + struct snd_card *card = fmixer->card; + struct snd_mixer_oss *mixer = fmixer->mixer; + struct snd_kcontrol *kctl; + struct snd_mixer_oss_slot *pslot; struct slot *slot = NULL; - snd_ctl_elem_info_t *uinfo; - snd_ctl_elem_value_t *uctl; + struct snd_ctl_elem_info *uinfo; + struct snd_ctl_elem_value *uctl; int err; unsigned int idx; @@ -878,11 +878,11 @@ struct snd_mixer_oss_assign_table { int index; }; -static int snd_mixer_oss_build_test(snd_mixer_oss_t *mixer, struct slot *slot, const char *name, int index, int item) +static int snd_mixer_oss_build_test(struct snd_mixer_oss *mixer, struct slot *slot, const char *name, int index, int item) { - snd_ctl_elem_info_t *info; - snd_kcontrol_t *kcontrol; - snd_card_t *card = mixer->card; + struct snd_ctl_elem_info *info; + struct snd_kcontrol *kcontrol; + struct snd_card *card = mixer->card; int err; down_read(&card->controls_rwsem); @@ -910,7 +910,7 @@ static int snd_mixer_oss_build_test(snd_mixer_oss_t *mixer, struct slot *slot, c return 0; } -static void snd_mixer_oss_slot_free(snd_mixer_oss_slot_t *chn) +static void snd_mixer_oss_slot_free(struct snd_mixer_oss_slot *chn) { struct slot *p = (struct slot *)chn->private_data; if (p) { @@ -922,7 +922,7 @@ static void snd_mixer_oss_slot_free(snd_mixer_oss_slot_t *chn) } } -static void mixer_slot_clear(snd_mixer_oss_slot_t *rslot) +static void mixer_slot_clear(struct snd_mixer_oss_slot *rslot) { int idx = rslot->number; /* remember this */ if (rslot->private_free) @@ -936,12 +936,12 @@ static void mixer_slot_clear(snd_mixer_oss_slot_t *rslot) * ptr_allocated means the entry is dynamically allocated (change via proc file). * when replace_old = 1, the old entry is replaced with the new one. */ -static int snd_mixer_oss_build_input(snd_mixer_oss_t *mixer, struct snd_mixer_oss_assign_table *ptr, int ptr_allocated, int replace_old) +static int snd_mixer_oss_build_input(struct snd_mixer_oss *mixer, struct snd_mixer_oss_assign_table *ptr, int ptr_allocated, int replace_old) { struct slot slot; struct slot *pslot; - snd_kcontrol_t *kctl; - snd_mixer_oss_slot_t *rslot; + struct snd_kcontrol *kctl; + struct snd_mixer_oss_slot *rslot; char str[64]; /* check if already assigned */ @@ -991,7 +991,7 @@ static int snd_mixer_oss_build_input(snd_mixer_oss_t *mixer, struct snd_mixer_os return 0; down_read(&mixer->card->controls_rwsem); if (ptr->index == 0 && (kctl = snd_mixer_oss_test_id(mixer, "Capture Source", 0)) != NULL) { - snd_ctl_elem_info_t *uinfo; + struct snd_ctl_elem_info *uinfo; uinfo = kmalloc(sizeof(*uinfo), GFP_KERNEL); if (! uinfo) { @@ -1093,10 +1093,10 @@ static char *oss_mixer_names[SNDRV_OSS_MAX_MIXERS] = { * /proc interface */ -static void snd_mixer_oss_proc_read(snd_info_entry_t *entry, - snd_info_buffer_t * buffer) +static void snd_mixer_oss_proc_read(struct snd_info_entry *entry, + struct snd_info_buffer *buffer) { - snd_mixer_oss_t *mixer = entry->private_data; + struct snd_mixer_oss *mixer = entry->private_data; int i; down(&mixer->reg_mutex); @@ -1117,10 +1117,10 @@ static void snd_mixer_oss_proc_read(snd_info_entry_t *entry, up(&mixer->reg_mutex); } -static void snd_mixer_oss_proc_write(snd_info_entry_t *entry, - snd_info_buffer_t * buffer) +static void snd_mixer_oss_proc_write(struct snd_info_entry *entry, + struct snd_info_buffer *buffer) { - snd_mixer_oss_t *mixer = entry->private_data; + struct snd_mixer_oss *mixer = entry->private_data; char line[128], str[32], idxstr[16], *cptr; int ch, idx; struct snd_mixer_oss_assign_table *tbl; @@ -1176,9 +1176,9 @@ static void snd_mixer_oss_proc_write(snd_info_entry_t *entry, } } -static void snd_mixer_oss_proc_init(snd_mixer_oss_t *mixer) +static void snd_mixer_oss_proc_init(struct snd_mixer_oss *mixer) { - snd_info_entry_t *entry; + struct snd_info_entry *entry; entry = snd_info_create_card_entry(mixer->card, "oss_mixer", mixer->card->proc_root); @@ -1198,7 +1198,7 @@ static void snd_mixer_oss_proc_init(snd_mixer_oss_t *mixer) mixer->proc_entry = entry; } -static void snd_mixer_oss_proc_done(snd_mixer_oss_t *mixer) +static void snd_mixer_oss_proc_done(struct snd_mixer_oss *mixer) { if (mixer->proc_entry) { snd_info_unregister(mixer->proc_entry); @@ -1206,7 +1206,7 @@ static void snd_mixer_oss_proc_done(snd_mixer_oss_t *mixer) } } -static void snd_mixer_oss_build(snd_mixer_oss_t *mixer) +static void snd_mixer_oss_build(struct snd_mixer_oss *mixer) { static struct snd_mixer_oss_assign_table table[] = { { SOUND_MIXER_VOLUME, "Master", 0 }, @@ -1260,8 +1260,8 @@ static void snd_mixer_oss_build(snd_mixer_oss_t *mixer) static int snd_mixer_oss_free1(void *private) { - snd_mixer_oss_t *mixer = private; - snd_card_t * card; + struct snd_mixer_oss *mixer = private; + struct snd_card *card; int idx; snd_assert(mixer != NULL, return -ENXIO); @@ -1269,7 +1269,7 @@ static int snd_mixer_oss_free1(void *private) snd_assert(mixer == card->mixer_oss, return -ENXIO); card->mixer_oss = NULL; for (idx = 0; idx < SNDRV_OSS_MAX_MIXERS; idx++) { - snd_mixer_oss_slot_t *chn = &mixer->slots[idx]; + struct snd_mixer_oss_slot *chn = &mixer->slots[idx]; if (chn->private_free) chn->private_free(chn); } @@ -1277,9 +1277,9 @@ static int snd_mixer_oss_free1(void *private) return 0; } -static int snd_mixer_oss_notify_handler(snd_card_t * card, int cmd) +static int snd_mixer_oss_notify_handler(struct snd_card *card, int cmd) { - snd_mixer_oss_t *mixer; + struct snd_mixer_oss *mixer; if (cmd == SND_MIXER_OSS_NOTIFY_REGISTER) { char name[128]; -- cgit v1.2.3 From 2af677fc884fc6dc79e65c99050ea607ac8bab9b Mon Sep 17 00:00:00 2001 From: Clemens Ladisch Date: Sun, 20 Nov 2005 14:03:48 +0100 Subject: [ALSA] dynamic minors (1/6): store device type in struct snd_minor Instead of a comment string, store the device type in the snd_minor structure. This makes snd_minor more flexible, and has the nice side effect that we don't need anymore to create a separate snd_minor template for registering a device but can pass the file_operations directly to snd_register_device(). Signed-off-by: Clemens Ladisch --- include/sound/core.h | 8 ++++--- include/sound/pcm.h | 3 +-- sound/core/control.c | 11 +++------ sound/core/hwdep.c | 11 +++------ sound/core/oss/mixer_oss.c | 8 +------ sound/core/oss/pcm_oss.c | 8 +------ sound/core/pcm.c | 6 +++-- sound/core/pcm_native.c | 53 +++++++++++++++++------------------------- sound/core/rawmidi.c | 14 ++++------- sound/core/seq/oss/seq_oss.c | 9 ++----- sound/core/seq/seq_clientmgr.c | 10 ++------ sound/core/sound.c | 38 ++++++++++++++++++++++++------ sound/core/sound_oss.c | 35 ++++++++++++++++++++++------ sound/core/timer.c | 8 +------ 14 files changed, 108 insertions(+), 114 deletions(-) (limited to 'sound/core/oss/mixer_oss.c') diff --git a/include/sound/core.h b/include/sound/core.h index f00b9c9b567f..f557c8ac450e 100644 --- a/include/sound/core.h +++ b/include/sound/core.h @@ -185,8 +185,8 @@ static inline int snd_power_wait(struct snd_card *card, unsigned int state, stru struct snd_minor { struct list_head list; /* list of all minors per card */ int number; /* minor number */ + int type; /* SNDRV_DEVICE_TYPE_XXX */ int device; /* device number */ - const char *comment; /* for /proc/asound/devices */ struct file_operations *f_ops; /* file operations */ char name[0]; /* device name (keep at the end of structure) */ @@ -199,11 +199,13 @@ extern int snd_ecards_limit; void snd_request_card(int card); -int snd_register_device(int type, struct snd_card *card, int dev, struct snd_minor *reg, const char *name); +int snd_register_device(int type, struct snd_card *card, int dev, + struct file_operations *f_ops, const char *name); int snd_unregister_device(int type, struct snd_card *card, int dev); #ifdef CONFIG_SND_OSSEMUL -int snd_register_oss_device(int type, struct snd_card *card, int dev, struct snd_minor *reg, const char *name); +int snd_register_oss_device(int type, struct snd_card *card, int dev, + struct file_operations *f_ops, const char *name); int snd_unregister_oss_device(int type, struct snd_card *card, int dev); #endif diff --git a/include/sound/pcm.h b/include/sound/pcm.h index 7e77c0add80a..5e29b0e0f214 100644 --- a/include/sound/pcm.h +++ b/include/sound/pcm.h @@ -402,7 +402,6 @@ struct snd_pcm_str { struct snd_pcm_oss_stream oss; #endif struct snd_pcm_file *files; - struct snd_minor *reg; struct snd_info_entry *proc_root; struct snd_info_entry *proc_info_entry; #ifdef CONFIG_SND_DEBUG @@ -441,7 +440,7 @@ struct snd_pcm_notify { */ extern struct snd_pcm *snd_pcm_devices[]; -extern struct snd_minor snd_pcm_reg[2]; +extern struct file_operations snd_pcm_f_ops[2]; int snd_pcm_new(struct snd_card *card, char *id, int device, int playback_count, int capture_count, diff --git a/sound/core/control.c b/sound/core/control.c index f8f98cc52417..23561e74712b 100644 --- a/sound/core/control.c +++ b/sound/core/control.c @@ -1264,12 +1264,6 @@ static struct file_operations snd_ctl_f_ops = .fasync = snd_ctl_fasync, }; -static struct snd_minor snd_ctl_reg = -{ - .comment = "ctl", - .f_ops = &snd_ctl_f_ops, -}; - /* * registration of the control device */ @@ -1284,7 +1278,7 @@ static int snd_ctl_dev_register(struct snd_device *device) snd_assert(cardnum >= 0 && cardnum < SNDRV_CARDS, return -ENXIO); sprintf(name, "controlC%i", cardnum); if ((err = snd_register_device(SNDRV_DEVICE_TYPE_CONTROL, - card, 0, &snd_ctl_reg, name)) < 0) + card, -1, &snd_ctl_f_ops, name)) < 0) return err; return 0; } @@ -1336,7 +1330,8 @@ static int snd_ctl_dev_unregister(struct snd_device *device) snd_assert(card != NULL, return -ENXIO); cardnum = card->number; snd_assert(cardnum >= 0 && cardnum < SNDRV_CARDS, return -ENXIO); - if ((err = snd_unregister_device(SNDRV_DEVICE_TYPE_CONTROL, card, 0)) < 0) + if ((err = snd_unregister_device(SNDRV_DEVICE_TYPE_CONTROL, + card, -1)) < 0) return err; return snd_ctl_dev_free(device); } diff --git a/sound/core/hwdep.c b/sound/core/hwdep.c index 444e266e7c48..27d5bf7266f0 100644 --- a/sound/core/hwdep.c +++ b/sound/core/hwdep.c @@ -330,12 +330,6 @@ static struct file_operations snd_hwdep_f_ops = .mmap = snd_hwdep_mmap, }; -static struct snd_minor snd_hwdep_reg = -{ - .comment = "hardware dependent", - .f_ops = &snd_hwdep_f_ops, -}; - /** * snd_hwdep_new - create a new hwdep instance * @card: the card instance @@ -416,7 +410,7 @@ static int snd_hwdep_dev_register(struct snd_device *device) sprintf(name, "hwC%iD%i", hwdep->card->number, hwdep->device); if ((err = snd_register_device(SNDRV_DEVICE_TYPE_HWDEP, hwdep->card, hwdep->device, - &snd_hwdep_reg, name)) < 0) { + &snd_hwdep_f_ops, name)) < 0) { snd_printk(KERN_ERR "unable to register hardware dependent device %i:%i\n", hwdep->card->number, hwdep->device); snd_hwdep_devices[idx] = NULL; @@ -431,7 +425,8 @@ static int snd_hwdep_dev_register(struct snd_device *device) } else { if (snd_register_oss_device(hwdep->oss_type, hwdep->card, hwdep->device, - &snd_hwdep_reg, hwdep->oss_dev) < 0) { + &snd_hwdep_f_ops, + hwdep->oss_dev) < 0) { snd_printk(KERN_ERR "unable to register OSS compatibility device %i:%i\n", hwdep->card->number, hwdep->device); } else diff --git a/sound/core/oss/mixer_oss.c b/sound/core/oss/mixer_oss.c index e448002ca7b9..2dd6bf9b49ed 100644 --- a/sound/core/oss/mixer_oss.c +++ b/sound/core/oss/mixer_oss.c @@ -398,12 +398,6 @@ static struct file_operations snd_mixer_oss_f_ops = .compat_ioctl = snd_mixer_oss_ioctl_compat, }; -static struct snd_minor snd_mixer_oss_reg = -{ - .comment = "mixer", - .f_ops = &snd_mixer_oss_f_ops, -}; - /* * utilities */ @@ -1292,7 +1286,7 @@ static int snd_mixer_oss_notify_handler(struct snd_card *card, int cmd) sprintf(name, "mixer%i%i", card->number, 0); if ((err = snd_register_oss_device(SNDRV_OSS_DEVICE_TYPE_MIXER, card, 0, - &snd_mixer_oss_reg, + &snd_mixer_oss_f_ops, name)) < 0) { snd_printk(KERN_ERR "unable to register OSS mixer device %i:%i\n", card->number, 0); diff --git a/sound/core/oss/pcm_oss.c b/sound/core/oss/pcm_oss.c index ffc13b9194b7..947bf08df42a 100644 --- a/sound/core/oss/pcm_oss.c +++ b/sound/core/oss/pcm_oss.c @@ -2444,18 +2444,12 @@ static struct file_operations snd_pcm_oss_f_reg = .mmap = snd_pcm_oss_mmap, }; -static struct snd_minor snd_pcm_oss_reg = -{ - .comment = "digital audio", - .f_ops = &snd_pcm_oss_f_reg, -}; - static void register_oss_dsp(struct snd_pcm *pcm, int index) { char name[128]; sprintf(name, "dsp%i%i", pcm->card->number, pcm->device); if (snd_register_oss_device(SNDRV_OSS_DEVICE_TYPE_PCM, - pcm->card, index, &snd_pcm_oss_reg, + pcm->card, index, &snd_pcm_oss_f_reg, name) < 0) { snd_printk(KERN_ERR "unable to register OSS PCM device %i:%i\n", pcm->card->number, pcm->device); diff --git a/sound/core/pcm.c b/sound/core/pcm.c index 9305ac357a3e..2bc5f69ec2a8 100644 --- a/sound/core/pcm.c +++ b/sound/core/pcm.c @@ -597,7 +597,6 @@ int snd_pcm_new_stream(struct snd_pcm *pcm, int stream, int substream_count) pstr->stream = stream; pstr->pcm = pcm; pstr->substream_count = substream_count; - pstr->reg = &snd_pcm_reg[stream]; if (substream_count > 0) { err = snd_pcm_stream_proc_init(pstr); if (err < 0) { @@ -897,7 +896,10 @@ static int snd_pcm_dev_register(struct snd_device *device) devtype = SNDRV_DEVICE_TYPE_PCM_CAPTURE; break; } - if ((err = snd_register_device(devtype, pcm->card, pcm->device, pcm->streams[cidx].reg, str)) < 0) { + if ((err = snd_register_device(devtype, pcm->card, + pcm->device, + &snd_pcm_f_ops[cidx], str)) < 0) + { snd_pcm_devices[idx] = NULL; up(®ister_mutex); return err; diff --git a/sound/core/pcm_native.c b/sound/core/pcm_native.c index 7bac1cbe38da..bb40c016135e 100644 --- a/sound/core/pcm_native.c +++ b/sound/core/pcm_native.c @@ -3370,40 +3370,29 @@ out: * Register section */ -static struct file_operations snd_pcm_f_ops_playback = { - .owner = THIS_MODULE, - .write = snd_pcm_write, - .writev = snd_pcm_writev, - .open = snd_pcm_open, - .release = snd_pcm_release, - .poll = snd_pcm_playback_poll, - .unlocked_ioctl = snd_pcm_playback_ioctl, - .compat_ioctl = snd_pcm_ioctl_compat, - .mmap = snd_pcm_mmap, - .fasync = snd_pcm_fasync, -}; - -static struct file_operations snd_pcm_f_ops_capture = { - .owner = THIS_MODULE, - .read = snd_pcm_read, - .readv = snd_pcm_readv, - .open = snd_pcm_open, - .release = snd_pcm_release, - .poll = snd_pcm_capture_poll, - .unlocked_ioctl = snd_pcm_capture_ioctl, - .compat_ioctl = snd_pcm_ioctl_compat, - .mmap = snd_pcm_mmap, - .fasync = snd_pcm_fasync, -}; - -struct snd_minor snd_pcm_reg[2] = -{ +struct file_operations snd_pcm_f_ops[2] = { { - .comment = "digital audio playback", - .f_ops = &snd_pcm_f_ops_playback, + .owner = THIS_MODULE, + .write = snd_pcm_write, + .writev = snd_pcm_writev, + .open = snd_pcm_open, + .release = snd_pcm_release, + .poll = snd_pcm_playback_poll, + .unlocked_ioctl = snd_pcm_playback_ioctl, + .compat_ioctl = snd_pcm_ioctl_compat, + .mmap = snd_pcm_mmap, + .fasync = snd_pcm_fasync, }, { - .comment = "digital audio capture", - .f_ops = &snd_pcm_f_ops_capture, + .owner = THIS_MODULE, + .read = snd_pcm_read, + .readv = snd_pcm_readv, + .open = snd_pcm_open, + .release = snd_pcm_release, + .poll = snd_pcm_capture_poll, + .unlocked_ioctl = snd_pcm_capture_ioctl, + .compat_ioctl = snd_pcm_ioctl_compat, + .mmap = snd_pcm_mmap, + .fasync = snd_pcm_fasync, } }; diff --git a/sound/core/rawmidi.c b/sound/core/rawmidi.c index d703545cae8a..7ac77e5ddcb1 100644 --- a/sound/core/rawmidi.c +++ b/sound/core/rawmidi.c @@ -1367,12 +1367,6 @@ static struct file_operations snd_rawmidi_f_ops = .compat_ioctl = snd_rawmidi_ioctl_compat, }; -static struct snd_minor snd_rawmidi_reg = -{ - .comment = "raw midi", - .f_ops = &snd_rawmidi_f_ops, -}; - static int snd_rawmidi_alloc_substreams(struct snd_rawmidi *rmidi, struct snd_rawmidi_str *stream, int direction, @@ -1516,7 +1510,7 @@ static int snd_rawmidi_dev_register(struct snd_device *device) sprintf(name, "midiC%iD%i", rmidi->card->number, rmidi->device); if ((err = snd_register_device(SNDRV_DEVICE_TYPE_RAWMIDI, rmidi->card, rmidi->device, - &snd_rawmidi_reg, name)) < 0) { + &snd_rawmidi_f_ops, name)) < 0) { snd_printk(KERN_ERR "unable to register rawmidi device %i:%i\n", rmidi->card->number, rmidi->device); snd_rawmidi_devices[idx] = NULL; up(®ister_mutex); @@ -1533,7 +1527,8 @@ static int snd_rawmidi_dev_register(struct snd_device *device) rmidi->ossreg = 0; if ((int)rmidi->device == midi_map[rmidi->card->number]) { if (snd_register_oss_device(SNDRV_OSS_DEVICE_TYPE_MIDI, - rmidi->card, 0, &snd_rawmidi_reg, name) < 0) { + rmidi->card, 0, + &snd_rawmidi_f_ops, name) < 0) { snd_printk(KERN_ERR "unable to register OSS rawmidi device %i:%i\n", rmidi->card->number, 0); } else { rmidi->ossreg++; @@ -1544,7 +1539,8 @@ static int snd_rawmidi_dev_register(struct snd_device *device) } if ((int)rmidi->device == amidi_map[rmidi->card->number]) { if (snd_register_oss_device(SNDRV_OSS_DEVICE_TYPE_MIDI, - rmidi->card, 1, &snd_rawmidi_reg, name) < 0) { + rmidi->card, 1, + &snd_rawmidi_f_ops, name) < 0) { snd_printk(KERN_ERR "unable to register OSS rawmidi device %i:%i\n", rmidi->card->number, 1); } else { rmidi->ossreg++; diff --git a/sound/core/seq/oss/seq_oss.c b/sound/core/seq/oss/seq_oss.c index 2371e41b13ef..61c0a41376fd 100644 --- a/sound/core/seq/oss/seq_oss.c +++ b/sound/core/seq/oss/seq_oss.c @@ -217,11 +217,6 @@ static struct file_operations seq_oss_f_ops = .compat_ioctl = odev_ioctl_compat, }; -static struct snd_minor seq_oss_reg = { - .comment = "sequencer", - .f_ops = &seq_oss_f_ops, -}; - static int __init register_device(void) { @@ -230,7 +225,7 @@ register_device(void) down(®ister_mutex); if ((rc = snd_register_oss_device(SNDRV_OSS_DEVICE_TYPE_SEQUENCER, NULL, 0, - &seq_oss_reg, + &seq_oss_f_ops, SNDRV_SEQ_OSS_DEVNAME)) < 0) { snd_printk(KERN_ERR "can't register device seq\n"); up(®ister_mutex); @@ -238,7 +233,7 @@ register_device(void) } if ((rc = snd_register_oss_device(SNDRV_OSS_DEVICE_TYPE_MUSIC, NULL, 0, - &seq_oss_reg, + &seq_oss_f_ops, SNDRV_SEQ_OSS_DEVNAME)) < 0) { snd_printk(KERN_ERR "can't register device music\n"); snd_unregister_oss_device(SNDRV_OSS_DEVICE_TYPE_SEQUENCER, NULL, 0); diff --git a/sound/core/seq/seq_clientmgr.c b/sound/core/seq/seq_clientmgr.c index 5eab4201c640..087fdf32732b 100644 --- a/sound/core/seq/seq_clientmgr.c +++ b/sound/core/seq/seq_clientmgr.c @@ -2520,13 +2520,6 @@ static struct file_operations snd_seq_f_ops = .compat_ioctl = snd_seq_ioctl_compat, }; -static struct snd_minor snd_seq_reg = -{ - .comment = "sequencer", - .f_ops = &snd_seq_f_ops, -}; - - /* * register sequencer device */ @@ -2537,7 +2530,8 @@ int __init snd_sequencer_device_init(void) if (down_interruptible(®ister_mutex)) return -ERESTARTSYS; - if ((err = snd_register_device(SNDRV_DEVICE_TYPE_SEQUENCER, NULL, 0, &snd_seq_reg, "seq")) < 0) { + if ((err = snd_register_device(SNDRV_DEVICE_TYPE_SEQUENCER, NULL, 0, + &snd_seq_f_ops, "seq")) < 0) { up(®ister_mutex); return err; } diff --git a/sound/core/sound.c b/sound/core/sound.c index fb236a6b9c34..798c24c2de20 100644 --- a/sound/core/sound.c +++ b/sound/core/sound.c @@ -195,7 +195,7 @@ static int snd_kernel_minor(int type, struct snd_card *card, int dev) * @type: the device type, SNDRV_DEVICE_TYPE_XXX * @card: the card instance * @dev: the device index - * @reg: the struct snd_minor record + * @f_ops: the file operations * @name: the device file name * * Registers an ALSA device file for the given card. @@ -203,7 +203,8 @@ static int snd_kernel_minor(int type, struct snd_card *card, int dev) * * Retrurns zero if successful, or a negative error code on failure. */ -int snd_register_device(int type, struct snd_card *card, int dev, struct snd_minor * reg, const char *name) +int snd_register_device(int type, struct snd_card *card, int dev, + struct file_operations *f_ops, const char *name) { int minor = snd_kernel_minor(type, card, dev); struct snd_minor *preg; @@ -212,12 +213,13 @@ int snd_register_device(int type, struct snd_card *card, int dev, struct snd_min if (minor < 0) return minor; snd_assert(name, return -EINVAL); - preg = kmalloc(sizeof(struct snd_minor) + strlen(name) + 1, GFP_KERNEL); + preg = kzalloc(sizeof(struct snd_minor) + strlen(name) + 1, GFP_KERNEL); if (preg == NULL) return -ENOMEM; - *preg = *reg; preg->number = minor; + preg->type = type; preg->device = dev; + preg->f_ops = f_ops; strcpy(preg->name, name); down(&sound_mutex); if (snd_minor_search(minor)) { @@ -276,6 +278,28 @@ int snd_unregister_device(int type, struct snd_card *card, int dev) static struct snd_info_entry *snd_minor_info_entry = NULL; +static const char *snd_device_type_name(int type) +{ + switch (type) { + case SNDRV_DEVICE_TYPE_CONTROL: + return "control"; + case SNDRV_DEVICE_TYPE_HWDEP: + return "hardware dependent"; + case SNDRV_DEVICE_TYPE_RAWMIDI: + return "raw midi"; + case SNDRV_DEVICE_TYPE_PCM_PLAYBACK: + return "digital audio playback"; + case SNDRV_DEVICE_TYPE_PCM_CAPTURE: + return "digital audio capture"; + case SNDRV_DEVICE_TYPE_SEQUENCER: + return "sequencer"; + case SNDRV_DEVICE_TYPE_TIMER: + return "timer"; + default: + return "?"; + } +} + static void snd_minor_info_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer) { int card, device; @@ -288,11 +312,11 @@ static void snd_minor_info_read(struct snd_info_entry *entry, struct snd_info_bu mptr = list_entry(list, struct snd_minor, list); if (SNDRV_MINOR_DEVICE(mptr->number) != SNDRV_MINOR_GLOBAL) { if ((device = mptr->device) >= 0) - snd_iprintf(buffer, "%3i: [%i-%2i]: %s\n", mptr->number, card, device, mptr->comment); + snd_iprintf(buffer, "%3i: [%i-%2i]: %s\n", mptr->number, card, device, snd_device_type_name(mptr->type)); else - snd_iprintf(buffer, "%3i: [%i] : %s\n", mptr->number, card, mptr->comment); + snd_iprintf(buffer, "%3i: [%i] : %s\n", mptr->number, card, snd_device_type_name(mptr->type)); } else { - snd_iprintf(buffer, "%3i: : %s\n", mptr->number, mptr->comment); + snd_iprintf(buffer, "%3i: : %s\n", mptr->number, snd_device_type_name(mptr->type)); } } } diff --git a/sound/core/sound_oss.c b/sound/core/sound_oss.c index ec37604ffb68..4d189ffaa764 100644 --- a/sound/core/sound_oss.c +++ b/sound/core/sound_oss.c @@ -91,7 +91,7 @@ static int snd_oss_kernel_minor(int type, struct snd_card *card, int dev) } int snd_register_oss_device(int type, struct snd_card *card, int dev, - struct snd_minor * reg, const char *name) + struct file_operations *f_ops, const char *name) { int minor = snd_oss_kernel_minor(type, card, dev); int minor_unit; @@ -103,12 +103,13 @@ int snd_register_oss_device(int type, struct snd_card *card, int dev, if (minor < 0) return minor; - preg = (struct snd_minor *)kmalloc(sizeof(struct snd_minor), GFP_KERNEL); + preg = kzalloc(sizeof(struct snd_minor), GFP_KERNEL); if (preg == NULL) return -ENOMEM; - *preg = *reg; preg->number = minor; + preg->type = type; preg->device = dev; + preg->f_ops = f_ops; down(&sound_oss_mutex); list_add_tail(&preg->list, &snd_oss_minors_hash[cidx]); minor_unit = SNDRV_MINOR_OSS_DEVICE(minor); @@ -125,11 +126,12 @@ int snd_register_oss_device(int type, struct snd_card *card, int dev, } if (card) carddev = card->dev; - register1 = register_sound_special_device(reg->f_ops, minor, carddev); + register1 = register_sound_special_device(f_ops, minor, carddev); if (register1 != minor) goto __end; if (track2 >= 0) { - register2 = register_sound_special_device(reg->f_ops, track2, carddev); + register2 = register_sound_special_device(f_ops, track2, + carddev); if (register2 != track2) goto __end; } @@ -190,6 +192,25 @@ int snd_unregister_oss_device(int type, struct snd_card *card, int dev) static struct snd_info_entry *snd_minor_info_oss_entry = NULL; +static const char *snd_oss_device_type_name(int type) +{ + switch (type) { + case SNDRV_OSS_DEVICE_TYPE_MIXER: + return "mixer"; + case SNDRV_OSS_DEVICE_TYPE_SEQUENCER: + case SNDRV_OSS_DEVICE_TYPE_MUSIC: + return "sequencer"; + case SNDRV_OSS_DEVICE_TYPE_PCM: + return "digital audio"; + case SNDRV_OSS_DEVICE_TYPE_MIDI: + return "raw midi"; + case SNDRV_OSS_DEVICE_TYPE_DMFM: + return "hardware dependent"; + default: + return "?"; + } +} + static void snd_minor_info_oss_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer) { @@ -205,9 +226,9 @@ static void snd_minor_info_oss_read(struct snd_info_entry *entry, if (dev != SNDRV_MINOR_OSS_SNDSTAT && dev != SNDRV_MINOR_OSS_SEQUENCER && dev != SNDRV_MINOR_OSS_MUSIC) - snd_iprintf(buffer, "%3i: [%i-%2i]: %s\n", mptr->number, card, dev, mptr->comment); + snd_iprintf(buffer, "%3i: [%i-%2i]: %s\n", mptr->number, card, dev, snd_oss_device_type_name(mptr->type)); else - snd_iprintf(buffer, "%3i: : %s\n", mptr->number, mptr->comment); + snd_iprintf(buffer, "%3i: : %s\n", mptr->number, snd_oss_device_type_name(mptr->type)); } } up(&sound_oss_mutex); diff --git a/sound/core/timer.c b/sound/core/timer.c index 6aad411dd7b8..a7bcb04263cb 100644 --- a/sound/core/timer.c +++ b/sound/core/timer.c @@ -1924,12 +1924,6 @@ static struct file_operations snd_timer_f_ops = .fasync = snd_timer_user_fasync, }; -static struct snd_minor snd_timer_reg = -{ - .comment = "timer", - .f_ops = &snd_timer_f_ops, -}; - /* * ENTRY functions */ @@ -1959,7 +1953,7 @@ static int __init alsa_timer_init(void) snd_printk(KERN_ERR "unable to register system timer (%i)\n", err); if ((err = snd_register_device(SNDRV_DEVICE_TYPE_TIMER, - NULL, 0, &snd_timer_reg, "timer"))<0) + NULL, 0, &snd_timer_f_ops, "timer")) < 0) snd_printk(KERN_ERR "unable to register timer device (%i)\n", err); return 0; -- cgit v1.2.3 From f87135f56cb266e031f5ec081dfbde7e43f55e80 Mon Sep 17 00:00:00 2001 From: Clemens Ladisch Date: Sun, 20 Nov 2005 14:06:59 +0100 Subject: [ALSA] dynamic minors (3/6): store device-specific object pointers dynamically Instead of storing the pointers to the device-specific structures in an array, put them into the struct snd_minor, and look them up dynamically. This makes the device type modules independent of the minor number encoding. Signed-off-by: Clemens Ladisch --- include/sound/core.h | 9 +++- include/sound/hwdep.h | 1 + include/sound/pcm.h | 2 +- include/sound/rawmidi.h | 6 +-- sound/core/control.c | 7 ++- sound/core/hwdep.c | 91 +++++++++++++++---------------- sound/core/oss/mixer_oss.c | 7 +-- sound/core/oss/pcm_oss.c | 14 ++--- sound/core/pcm.c | 118 +++++++++++++++++++++++------------------ sound/core/pcm_native.c | 40 +++++++++----- sound/core/rawmidi.c | 87 +++++++++++++++--------------- sound/core/seq/oss/seq_oss.c | 4 +- sound/core/seq/seq_clientmgr.c | 2 +- sound/core/seq/seq_midi.c | 10 +++- sound/core/sound.c | 46 +++++++++++++--- sound/core/sound_oss.c | 27 ++++++++-- sound/core/timer.c | 4 +- 17 files changed, 278 insertions(+), 197 deletions(-) (limited to 'sound/core/oss/mixer_oss.c') diff --git a/include/sound/core.h b/include/sound/core.h index 67b0a7e764e7..90ac6132ea3b 100644 --- a/include/sound/core.h +++ b/include/sound/core.h @@ -187,6 +187,7 @@ struct snd_minor { int card; /* card number */ int device; /* device number */ struct file_operations *f_ops; /* file operations */ + void *private_data; /* private data for f_ops->open */ char name[0]; /* device name (keep at the end of structure) */ }; @@ -199,13 +200,17 @@ extern int snd_ecards_limit; void snd_request_card(int card); int snd_register_device(int type, struct snd_card *card, int dev, - struct file_operations *f_ops, const char *name); + struct file_operations *f_ops, void *private_data, + const char *name); int snd_unregister_device(int type, struct snd_card *card, int dev); +void *snd_lookup_minor_data(unsigned int minor, int type); #ifdef CONFIG_SND_OSSEMUL int snd_register_oss_device(int type, struct snd_card *card, int dev, - struct file_operations *f_ops, const char *name); + struct file_operations *f_ops, void *private_data, + const char *name); int snd_unregister_oss_device(int type, struct snd_card *card, int dev); +void *snd_lookup_oss_minor_data(unsigned int minor, int type); #endif int snd_minor_info_init(void); diff --git a/include/sound/hwdep.h b/include/sound/hwdep.h index 04b20bc4f144..c679e5b31111 100644 --- a/include/sound/hwdep.h +++ b/include/sound/hwdep.h @@ -43,6 +43,7 @@ struct snd_hwdep_ops { struct snd_hwdep { struct snd_card *card; + struct list_head list; int device; char id[32]; char name[80]; diff --git a/include/sound/pcm.h b/include/sound/pcm.h index 5e29b0e0f214..314268a11048 100644 --- a/include/sound/pcm.h +++ b/include/sound/pcm.h @@ -412,6 +412,7 @@ struct snd_pcm_str { struct snd_pcm { struct snd_card *card; + struct list_head list; unsigned int device; /* device number */ unsigned int info_flags; unsigned short dev_class; @@ -439,7 +440,6 @@ struct snd_pcm_notify { * Registering */ -extern struct snd_pcm *snd_pcm_devices[]; extern struct file_operations snd_pcm_f_ops[2]; int snd_pcm_new(struct snd_card *card, char *id, int device, diff --git a/include/sound/rawmidi.h b/include/sound/rawmidi.h index 9492a32c1026..d19bddfbf995 100644 --- a/include/sound/rawmidi.h +++ b/include/sound/rawmidi.h @@ -113,7 +113,7 @@ struct snd_rawmidi_str { struct snd_rawmidi { struct snd_card *card; - + struct list_head list; unsigned int device; /* device number */ unsigned int info_flags; /* SNDRV_RAWMIDI_INFO_XXXX */ char id[64]; @@ -165,8 +165,8 @@ int snd_rawmidi_transmit(struct snd_rawmidi_substream *substream, /* main midi functions */ int snd_rawmidi_info_select(struct snd_card *card, struct snd_rawmidi_info *info); -int snd_rawmidi_kernel_open(int cardnum, int device, int subdevice, int mode, - struct snd_rawmidi_file *rfile); +int snd_rawmidi_kernel_open(struct snd_card *card, int device, int subdevice, + int mode, struct snd_rawmidi_file *rfile); int snd_rawmidi_kernel_release(struct snd_rawmidi_file *rfile); int snd_rawmidi_output_params(struct snd_rawmidi_substream *substream, struct snd_rawmidi_params *params); diff --git a/sound/core/control.c b/sound/core/control.c index 23561e74712b..abd62f943726 100644 --- a/sound/core/control.c +++ b/sound/core/control.c @@ -47,13 +47,12 @@ static LIST_HEAD(snd_control_compat_ioctls); static int snd_ctl_open(struct inode *inode, struct file *file) { - int cardnum = SNDRV_MINOR_CARD(iminor(inode)); unsigned long flags; struct snd_card *card; struct snd_ctl_file *ctl; int err; - card = snd_cards[cardnum]; + card = snd_lookup_minor_data(iminor(inode), SNDRV_DEVICE_TYPE_CONTROL); if (!card) { err = -ENODEV; goto __error1; @@ -1277,8 +1276,8 @@ static int snd_ctl_dev_register(struct snd_device *device) cardnum = card->number; snd_assert(cardnum >= 0 && cardnum < SNDRV_CARDS, return -ENXIO); sprintf(name, "controlC%i", cardnum); - if ((err = snd_register_device(SNDRV_DEVICE_TYPE_CONTROL, - card, -1, &snd_ctl_f_ops, name)) < 0) + if ((err = snd_register_device(SNDRV_DEVICE_TYPE_CONTROL, card, -1, + &snd_ctl_f_ops, card, name)) < 0) return err; return 0; } diff --git a/sound/core/hwdep.c b/sound/core/hwdep.c index 27d5bf7266f0..b8c0c8c4d126 100644 --- a/sound/core/hwdep.c +++ b/sound/core/hwdep.c @@ -35,8 +35,7 @@ MODULE_AUTHOR("Jaroslav Kysela "); MODULE_DESCRIPTION("Hardware dependent layer"); MODULE_LICENSE("GPL"); -static struct snd_hwdep *snd_hwdep_devices[SNDRV_CARDS * SNDRV_MINOR_HWDEPS]; - +static LIST_HEAD(snd_hwdep_devices); static DECLARE_MUTEX(register_mutex); static int snd_hwdep_free(struct snd_hwdep *hwdep); @@ -44,9 +43,19 @@ static int snd_hwdep_dev_free(struct snd_device *device); static int snd_hwdep_dev_register(struct snd_device *device); static int snd_hwdep_dev_unregister(struct snd_device *device); -/* - */ +static struct snd_hwdep *snd_hwdep_search(struct snd_card *card, int device) +{ + struct list_head *p; + struct snd_hwdep *hwdep; + + list_for_each(p, &snd_hwdep_devices) { + hwdep = list_entry(p, struct snd_hwdep, list); + if (hwdep->card == card && hwdep->device == device) + return hwdep; + } + return NULL; +} static loff_t snd_hwdep_llseek(struct file * file, loff_t offset, int orig) { @@ -77,34 +86,25 @@ static ssize_t snd_hwdep_write(struct file * file, const char __user *buf, static int snd_hwdep_open(struct inode *inode, struct file * file) { int major = imajor(inode); - int cardnum; - int device; struct snd_hwdep *hw; int err; wait_queue_t wait; if (major == snd_major) { - cardnum = SNDRV_MINOR_CARD(iminor(inode)); - device = SNDRV_MINOR_DEVICE(iminor(inode)) - SNDRV_MINOR_HWDEP; + hw = snd_lookup_minor_data(iminor(inode), + SNDRV_DEVICE_TYPE_HWDEP); #ifdef CONFIG_SND_OSSEMUL } else if (major == SOUND_MAJOR) { - cardnum = SNDRV_MINOR_OSS_CARD(iminor(inode)); - device = 0; + hw = snd_lookup_oss_minor_data(iminor(inode), + SNDRV_OSS_DEVICE_TYPE_DMFM); #endif } else return -ENXIO; - cardnum %= SNDRV_CARDS; - device %= SNDRV_MINOR_HWDEPS; - hw = snd_hwdep_devices[(cardnum * SNDRV_MINOR_HWDEPS) + device]; if (hw == NULL) return -ENODEV; if (!hw->ops.open) return -ENXIO; -#ifdef CONFIG_SND_OSSEMUL - if (major == SOUND_MAJOR && hw->oss_type < 0) - return -ENXIO; -#endif if (!try_module_get(hw->card->module)) return -EFAULT; @@ -265,9 +265,6 @@ static int snd_hwdep_control_ioctl(struct snd_card *card, struct snd_ctl_file * control, unsigned int cmd, unsigned long arg) { - unsigned int tmp; - - tmp = card->number * SNDRV_MINOR_HWDEPS; switch (cmd) { case SNDRV_CTL_IOCTL_HWDEP_NEXT_DEVICE: { @@ -275,14 +272,16 @@ static int snd_hwdep_control_ioctl(struct snd_card *card, if (get_user(device, (int __user *)arg)) return -EFAULT; + down(®ister_mutex); device = device < 0 ? 0 : device + 1; while (device < SNDRV_MINOR_HWDEPS) { - if (snd_hwdep_devices[tmp + device]) + if (snd_hwdep_search(card, device)) break; device++; } if (device >= SNDRV_MINOR_HWDEPS) device = -1; + up(®ister_mutex); if (put_user(device, (int __user *)arg)) return -EFAULT; return 0; @@ -290,17 +289,19 @@ static int snd_hwdep_control_ioctl(struct snd_card *card, case SNDRV_CTL_IOCTL_HWDEP_INFO: { struct snd_hwdep_info __user *info = (struct snd_hwdep_info __user *)arg; - int device; + int device, err; struct snd_hwdep *hwdep; if (get_user(device, &info->device)) return -EFAULT; - if (device < 0 || device >= SNDRV_MINOR_HWDEPS) - return -ENXIO; - hwdep = snd_hwdep_devices[tmp + device]; - if (hwdep == NULL) - return -ENXIO; - return snd_hwdep_info(hwdep, info); + down(®ister_mutex); + hwdep = snd_hwdep_search(card, device); + if (hwdep) + err = snd_hwdep_info(hwdep, info); + else + err = -ENXIO; + up(®ister_mutex); + return err; } } return -ENOIOCTLCMD; @@ -397,23 +398,22 @@ static int snd_hwdep_dev_free(struct snd_device *device) static int snd_hwdep_dev_register(struct snd_device *device) { struct snd_hwdep *hwdep = device->device_data; - int idx, err; + int err; char name[32]; down(®ister_mutex); - idx = (hwdep->card->number * SNDRV_MINOR_HWDEPS) + hwdep->device; - if (snd_hwdep_devices[idx]) { + if (snd_hwdep_search(hwdep->card, hwdep->device)) { up(®ister_mutex); return -EBUSY; } - snd_hwdep_devices[idx] = hwdep; + list_add_tail(&hwdep->list, &snd_hwdep_devices); sprintf(name, "hwC%iD%i", hwdep->card->number, hwdep->device); if ((err = snd_register_device(SNDRV_DEVICE_TYPE_HWDEP, hwdep->card, hwdep->device, - &snd_hwdep_f_ops, name)) < 0) { + &snd_hwdep_f_ops, hwdep, name)) < 0) { snd_printk(KERN_ERR "unable to register hardware dependent device %i:%i\n", hwdep->card->number, hwdep->device); - snd_hwdep_devices[idx] = NULL; + list_del(&hwdep->list); up(®ister_mutex); return err; } @@ -425,7 +425,7 @@ static int snd_hwdep_dev_register(struct snd_device *device) } else { if (snd_register_oss_device(hwdep->oss_type, hwdep->card, hwdep->device, - &snd_hwdep_f_ops, + &snd_hwdep_f_ops, hwdep, hwdep->oss_dev) < 0) { snd_printk(KERN_ERR "unable to register OSS compatibility device %i:%i\n", hwdep->card->number, hwdep->device); @@ -441,12 +441,10 @@ static int snd_hwdep_dev_register(struct snd_device *device) static int snd_hwdep_dev_unregister(struct snd_device *device) { struct snd_hwdep *hwdep = device->device_data; - int idx; snd_assert(hwdep != NULL, return -ENXIO); down(®ister_mutex); - idx = (hwdep->card->number * SNDRV_MINOR_HWDEPS) + hwdep->device; - if (snd_hwdep_devices[idx] != hwdep) { + if (snd_hwdep_search(hwdep->card, hwdep->device) != hwdep) { up(®ister_mutex); return -EINVAL; } @@ -455,7 +453,7 @@ static int snd_hwdep_dev_unregister(struct snd_device *device) snd_unregister_oss_device(hwdep->oss_type, hwdep->card, hwdep->device); #endif snd_unregister_device(SNDRV_DEVICE_TYPE_HWDEP, hwdep->card, hwdep->device); - snd_hwdep_devices[idx] = NULL; + list_del(&hwdep->list); up(®ister_mutex); return snd_hwdep_free(hwdep); } @@ -467,18 +465,14 @@ static int snd_hwdep_dev_unregister(struct snd_device *device) static void snd_hwdep_proc_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer) { - int idx; + struct list_head *p; struct snd_hwdep *hwdep; down(®ister_mutex); - for (idx = 0; idx < SNDRV_CARDS * SNDRV_MINOR_HWDEPS; idx++) { - hwdep = snd_hwdep_devices[idx]; - if (hwdep == NULL) - continue; + list_for_each(p, &snd_hwdep_devices) { + hwdep = list_entry(p, struct snd_hwdep, list); snd_iprintf(buffer, "%02i-%02i: %s\n", - idx / SNDRV_MINOR_HWDEPS, - idx % SNDRV_MINOR_HWDEPS, - hwdep->name); + hwdep->card->number, hwdep->device, hwdep->name); } up(®ister_mutex); } @@ -493,9 +487,8 @@ static int __init alsa_hwdep_init(void) { struct snd_info_entry *entry; - memset(snd_hwdep_devices, 0, sizeof(snd_hwdep_devices)); if ((entry = snd_info_create_module_entry(THIS_MODULE, "hwdep", NULL)) != NULL) { - entry->c.text.read_size = 512; + entry->c.text.read_size = PAGE_SIZE; entry->c.text.read = snd_hwdep_proc_read; if (snd_info_register(entry) < 0) { snd_info_free_entry(entry); diff --git a/sound/core/oss/mixer_oss.c b/sound/core/oss/mixer_oss.c index 2dd6bf9b49ed..2d7a42014f51 100644 --- a/sound/core/oss/mixer_oss.c +++ b/sound/core/oss/mixer_oss.c @@ -41,12 +41,13 @@ MODULE_ALIAS_SNDRV_MINOR(SNDRV_MINOR_OSS_MIXER); static int snd_mixer_oss_open(struct inode *inode, struct file *file) { - int cardnum = SNDRV_MINOR_OSS_CARD(iminor(inode)); struct snd_card *card; struct snd_mixer_oss_file *fmixer; int err; - if ((card = snd_cards[cardnum]) == NULL) + card = snd_lookup_oss_minor_data(iminor(inode), + SNDRV_OSS_DEVICE_TYPE_MIXER); + if (card == NULL) return -ENODEV; if (card->mixer_oss == NULL) return -ENODEV; @@ -1286,7 +1287,7 @@ static int snd_mixer_oss_notify_handler(struct snd_card *card, int cmd) sprintf(name, "mixer%i%i", card->number, 0); if ((err = snd_register_oss_device(SNDRV_OSS_DEVICE_TYPE_MIXER, card, 0, - &snd_mixer_oss_f_ops, + &snd_mixer_oss_f_ops, card, name)) < 0) { snd_printk(KERN_ERR "unable to register OSS mixer device %i:%i\n", card->number, 0); diff --git a/sound/core/oss/pcm_oss.c b/sound/core/oss/pcm_oss.c index 947bf08df42a..2ae283c7b28a 100644 --- a/sound/core/oss/pcm_oss.c +++ b/sound/core/oss/pcm_oss.c @@ -1834,9 +1834,6 @@ static int snd_task_name(struct task_struct *task, char *name, size_t size) static int snd_pcm_oss_open(struct inode *inode, struct file *file) { - int minor = iminor(inode); - int cardnum = SNDRV_MINOR_OSS_CARD(minor); - int device; int err; char task_name[32]; struct snd_pcm *pcm; @@ -1845,11 +1842,8 @@ static int snd_pcm_oss_open(struct inode *inode, struct file *file) int nonblock; wait_queue_t wait; - snd_assert(cardnum >= 0 && cardnum < SNDRV_CARDS, return -ENXIO); - device = SNDRV_MINOR_OSS_DEVICE(minor) == SNDRV_MINOR_OSS_PCM1 ? - adsp_map[cardnum] : dsp_map[cardnum]; - - pcm = snd_pcm_devices[(cardnum * SNDRV_PCM_DEVICES) + device]; + pcm = snd_lookup_oss_minor_data(iminor(inode), + SNDRV_OSS_DEVICE_TYPE_PCM); if (pcm == NULL) { err = -ENODEV; goto __error1; @@ -1890,7 +1884,7 @@ static int snd_pcm_oss_open(struct inode *inode, struct file *file) down(&pcm->open_mutex); while (1) { err = snd_pcm_oss_open_file(file, pcm, &pcm_oss_file, - minor, psetup, csetup); + iminor(inode), psetup, csetup); if (err >= 0) break; if (err == -EAGAIN) { @@ -2450,7 +2444,7 @@ static void register_oss_dsp(struct snd_pcm *pcm, int index) sprintf(name, "dsp%i%i", pcm->card->number, pcm->device); if (snd_register_oss_device(SNDRV_OSS_DEVICE_TYPE_PCM, pcm->card, index, &snd_pcm_oss_f_reg, - name) < 0) { + pcm, name) < 0) { snd_printk(KERN_ERR "unable to register OSS PCM device %i:%i\n", pcm->card->number, pcm->device); } diff --git a/sound/core/pcm.c b/sound/core/pcm.c index 2bc5f69ec2a8..95036c83de43 100644 --- a/sound/core/pcm.c +++ b/sound/core/pcm.c @@ -33,7 +33,7 @@ MODULE_AUTHOR("Jaroslav Kysela , Abramo Bagnara card == card && pcm->device == device) + return pcm; + } + return NULL; +} + static int snd_pcm_control_ioctl(struct snd_card *card, struct snd_ctl_file *control, unsigned int cmd, unsigned long arg) { - unsigned int tmp; - - tmp = card->number * SNDRV_PCM_DEVICES; switch (cmd) { case SNDRV_CTL_IOCTL_PCM_NEXT_DEVICE: { @@ -57,14 +67,16 @@ static int snd_pcm_control_ioctl(struct snd_card *card, if (get_user(device, (int __user *)arg)) return -EFAULT; + down(®ister_mutex); device = device < 0 ? 0 : device + 1; while (device < SNDRV_PCM_DEVICES) { - if (snd_pcm_devices[tmp + device]) + if (snd_pcm_search(card, device)) break; device++; } if (device == SNDRV_PCM_DEVICES) device = -1; + up(®ister_mutex); if (put_user(device, (int __user *)arg)) return -EFAULT; return 0; @@ -77,31 +89,44 @@ static int snd_pcm_control_ioctl(struct snd_card *card, struct snd_pcm *pcm; struct snd_pcm_str *pstr; struct snd_pcm_substream *substream; + int err; + info = (struct snd_pcm_info __user *)arg; if (get_user(device, &info->device)) return -EFAULT; - if (device >= SNDRV_PCM_DEVICES) - return -ENXIO; - pcm = snd_pcm_devices[tmp + device]; - if (pcm == NULL) - return -ENXIO; if (get_user(stream, &info->stream)) return -EFAULT; if (stream < 0 || stream > 1) return -EINVAL; - pstr = &pcm->streams[stream]; - if (pstr->substream_count == 0) - return -ENOENT; if (get_user(subdevice, &info->subdevice)) return -EFAULT; - if (subdevice >= pstr->substream_count) - return -ENXIO; - for (substream = pstr->substream; substream; substream = substream->next) + down(®ister_mutex); + pcm = snd_pcm_search(card, device); + if (pcm == NULL) { + err = -ENXIO; + goto _error; + } + pstr = &pcm->streams[stream]; + if (pstr->substream_count == 0) { + err = -ENOENT; + goto _error; + } + if (subdevice >= pstr->substream_count) { + err = -ENXIO; + goto _error; + } + for (substream = pstr->substream; substream; + substream = substream->next) if (substream->number == (int)subdevice) break; - if (substream == NULL) - return -ENXIO; - return snd_pcm_info_user(substream, info); + if (substream == NULL) { + err = -ENXIO; + goto _error; + } + err = snd_pcm_info_user(substream, info); + _error: + up(®ister_mutex); + return err; } case SNDRV_CTL_IOCTL_PCM_PREFER_SUBDEVICE: { @@ -865,8 +890,7 @@ void snd_pcm_release_substream(struct snd_pcm_substream *substream) static int snd_pcm_dev_register(struct snd_device *device) { - int idx, cidx, err; - unsigned short minor; + int cidx, err; struct snd_pcm_substream *substream; struct list_head *list; char str[16]; @@ -874,12 +898,11 @@ static int snd_pcm_dev_register(struct snd_device *device) snd_assert(pcm != NULL && device != NULL, return -ENXIO); down(®ister_mutex); - idx = (pcm->card->number * SNDRV_PCM_DEVICES) + pcm->device; - if (snd_pcm_devices[idx]) { + if (snd_pcm_search(pcm->card, pcm->device)) { up(®ister_mutex); return -EBUSY; } - snd_pcm_devices[idx] = pcm; + list_add_tail(&pcm->list, &snd_pcm_devices); for (cidx = 0; cidx < 2; cidx++) { int devtype = -1; if (pcm->streams[cidx].substream == NULL) @@ -887,20 +910,19 @@ static int snd_pcm_dev_register(struct snd_device *device) switch (cidx) { case SNDRV_PCM_STREAM_PLAYBACK: sprintf(str, "pcmC%iD%ip", pcm->card->number, pcm->device); - minor = SNDRV_MINOR_PCM_PLAYBACK + idx; devtype = SNDRV_DEVICE_TYPE_PCM_PLAYBACK; break; case SNDRV_PCM_STREAM_CAPTURE: sprintf(str, "pcmC%iD%ic", pcm->card->number, pcm->device); - minor = SNDRV_MINOR_PCM_CAPTURE + idx; devtype = SNDRV_DEVICE_TYPE_PCM_CAPTURE; break; } if ((err = snd_register_device(devtype, pcm->card, pcm->device, - &snd_pcm_f_ops[cidx], str)) < 0) + &snd_pcm_f_ops[cidx], + pcm, str)) < 0) { - snd_pcm_devices[idx] = NULL; + list_del(&pcm->list); up(®ister_mutex); return err; } @@ -921,11 +943,10 @@ static int snd_pcm_dev_disconnect(struct snd_device *device) struct snd_pcm *pcm = device->device_data; struct list_head *list; struct snd_pcm_substream *substream; - int idx, cidx; + int cidx; down(®ister_mutex); - idx = (pcm->card->number * SNDRV_PCM_DEVICES) + pcm->device; - snd_pcm_devices[idx] = NULL; + list_del_init(&pcm->list); for (cidx = 0; cidx < 2; cidx++) for (substream = pcm->streams[cidx].substream; substream; substream = substream->next) if (substream->runtime) @@ -941,15 +962,14 @@ static int snd_pcm_dev_disconnect(struct snd_device *device) static int snd_pcm_dev_unregister(struct snd_device *device) { - int idx, cidx, devtype; + int cidx, devtype; struct snd_pcm_substream *substream; struct list_head *list; struct snd_pcm *pcm = device->device_data; snd_assert(pcm != NULL, return -ENXIO); down(®ister_mutex); - idx = (pcm->card->number * SNDRV_PCM_DEVICES) + pcm->device; - snd_pcm_devices[idx] = NULL; + list_del(&pcm->list); for (cidx = 0; cidx < 2; cidx++) { devtype = -1; switch (cidx) { @@ -975,24 +995,19 @@ static int snd_pcm_dev_unregister(struct snd_device *device) int snd_pcm_notify(struct snd_pcm_notify *notify, int nfree) { - int idx; + struct list_head *p; snd_assert(notify != NULL && notify->n_register != NULL && notify->n_unregister != NULL, return -EINVAL); down(®ister_mutex); if (nfree) { list_del(¬ify->list); - for (idx = 0; idx < SNDRV_CARDS * SNDRV_PCM_DEVICES; idx++) { - if (snd_pcm_devices[idx] == NULL) - continue; - notify->n_unregister(snd_pcm_devices[idx]); - } + list_for_each(p, &snd_pcm_devices) + notify->n_unregister(list_entry(p, + struct snd_pcm, list)); } else { list_add_tail(¬ify->list, &snd_pcm_notify_list); - for (idx = 0; idx < SNDRV_CARDS * SNDRV_PCM_DEVICES; idx++) { - if (snd_pcm_devices[idx] == NULL) - continue; - notify->n_register(snd_pcm_devices[idx]); - } + list_for_each(p, &snd_pcm_devices) + notify->n_register(list_entry(p, struct snd_pcm, list)); } up(®ister_mutex); return 0; @@ -1005,16 +1020,14 @@ int snd_pcm_notify(struct snd_pcm_notify *notify, int nfree) static void snd_pcm_proc_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer) { - int idx; + struct list_head *p; struct snd_pcm *pcm; down(®ister_mutex); - for (idx = 0; idx < SNDRV_CARDS * SNDRV_PCM_DEVICES; idx++) { - pcm = snd_pcm_devices[idx]; - if (pcm == NULL) - continue; - snd_iprintf(buffer, "%02i-%02i: %s : %s", idx / SNDRV_PCM_DEVICES, - idx % SNDRV_PCM_DEVICES, pcm->id, pcm->name); + list_for_each(p, &snd_pcm_devices) { + pcm = list_entry(p, struct snd_pcm, list); + snd_iprintf(buffer, "%02i-%02i: %s : %s", + pcm->card->number, pcm->device, pcm->id, pcm->name); if (pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream) snd_iprintf(buffer, " : playback %i", pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream_count); @@ -1063,7 +1076,6 @@ static void __exit alsa_pcm_exit(void) module_init(alsa_pcm_init) module_exit(alsa_pcm_exit) -EXPORT_SYMBOL(snd_pcm_devices); EXPORT_SYMBOL(snd_pcm_new); EXPORT_SYMBOL(snd_pcm_new_stream); EXPORT_SYMBOL(snd_pcm_notify); diff --git a/sound/core/pcm_native.c b/sound/core/pcm_native.c index bb40c016135e..9010306bcead 100644 --- a/sound/core/pcm_native.c +++ b/sound/core/pcm_native.c @@ -62,6 +62,7 @@ static int snd_pcm_hw_refine_old_user(struct snd_pcm_substream *substream, struct snd_pcm_hw_params_old __user * _oparams); static int snd_pcm_hw_params_old_user(struct snd_pcm_substream *substream, struct snd_pcm_hw_params_old __user * _oparams); +static int snd_pcm_open(struct file *file, struct snd_pcm *pcm, int stream); /* * @@ -1554,7 +1555,8 @@ static struct file *snd_pcm_file_fd(int fd) { struct file *file; struct inode *inode; - unsigned short minor; + unsigned int minor; + file = fget(fd); if (!file) return NULL; @@ -1565,8 +1567,8 @@ static struct file *snd_pcm_file_fd(int fd) return NULL; } minor = iminor(inode); - if (minor >= 256 || - minor % SNDRV_MINOR_DEVICES < SNDRV_MINOR_PCM_PLAYBACK) { + if (!snd_lookup_minor_data(minor, SNDRV_DEVICE_TYPE_PCM_PLAYBACK) && + !snd_lookup_minor_data(minor, SNDRV_DEVICE_TYPE_PCM_CAPTURE)) { fput(file); return NULL; } @@ -2071,18 +2073,30 @@ static int snd_pcm_open_file(struct file *file, return 0; } -static int snd_pcm_open(struct inode *inode, struct file *file) +static int snd_pcm_playback_open(struct inode *inode, struct file *file) +{ + struct snd_pcm *pcm; + + pcm = snd_lookup_minor_data(iminor(inode), + SNDRV_DEVICE_TYPE_PCM_PLAYBACK); + return snd_pcm_open(file, pcm, SNDRV_PCM_STREAM_PLAYBACK); +} + +static int snd_pcm_capture_open(struct inode *inode, struct file *file) { - int cardnum = SNDRV_MINOR_CARD(iminor(inode)); - int device = SNDRV_MINOR_DEVICE(iminor(inode)); - int err; struct snd_pcm *pcm; + + pcm = snd_lookup_minor_data(iminor(inode), + SNDRV_DEVICE_TYPE_PCM_CAPTURE); + return snd_pcm_open(file, pcm, SNDRV_PCM_STREAM_CAPTURE); +} + +static int snd_pcm_open(struct file *file, struct snd_pcm *pcm, int stream) +{ + int err; struct snd_pcm_file *pcm_file; wait_queue_t wait; - if (device < SNDRV_MINOR_PCM_PLAYBACK || device >= SNDRV_MINOR_DEVICES) - return -ENXIO; - pcm = snd_pcm_devices[(cardnum * SNDRV_PCM_DEVICES) + (device % SNDRV_MINOR_PCMS)]; if (pcm == NULL) { err = -ENODEV; goto __error1; @@ -2098,7 +2112,7 @@ static int snd_pcm_open(struct inode *inode, struct file *file) add_wait_queue(&pcm->open_wait, &wait); down(&pcm->open_mutex); while (1) { - err = snd_pcm_open_file(file, pcm, device >= SNDRV_MINOR_PCM_CAPTURE ? SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK, &pcm_file); + err = snd_pcm_open_file(file, pcm, stream, &pcm_file); if (err >= 0) break; if (err == -EAGAIN) { @@ -3375,7 +3389,7 @@ struct file_operations snd_pcm_f_ops[2] = { .owner = THIS_MODULE, .write = snd_pcm_write, .writev = snd_pcm_writev, - .open = snd_pcm_open, + .open = snd_pcm_playback_open, .release = snd_pcm_release, .poll = snd_pcm_playback_poll, .unlocked_ioctl = snd_pcm_playback_ioctl, @@ -3387,7 +3401,7 @@ struct file_operations snd_pcm_f_ops[2] = { .owner = THIS_MODULE, .read = snd_pcm_read, .readv = snd_pcm_readv, - .open = snd_pcm_open, + .open = snd_pcm_capture_open, .release = snd_pcm_release, .poll = snd_pcm_capture_poll, .unlocked_ioctl = snd_pcm_capture_ioctl, diff --git a/sound/core/rawmidi.c b/sound/core/rawmidi.c index 7ac77e5ddcb1..e6ee0d813783 100644 --- a/sound/core/rawmidi.c +++ b/sound/core/rawmidi.c @@ -56,10 +56,22 @@ static int snd_rawmidi_dev_register(struct snd_device *device); static int snd_rawmidi_dev_disconnect(struct snd_device *device); static int snd_rawmidi_dev_unregister(struct snd_device *device); -static struct snd_rawmidi *snd_rawmidi_devices[SNDRV_CARDS * SNDRV_RAWMIDI_DEVICES]; - +static LIST_HEAD(snd_rawmidi_devices); static DECLARE_MUTEX(register_mutex); +static struct snd_rawmidi *snd_rawmidi_search(struct snd_card *card, int device) +{ + struct list_head *p; + struct snd_rawmidi *rawmidi; + + list_for_each(p, &snd_rawmidi_devices) { + rawmidi = list_entry(p, struct snd_rawmidi, list); + if (rawmidi->card == card && rawmidi->device == device) + return rawmidi; + } + return NULL; +} + static inline unsigned short snd_rawmidi_file_flags(struct file *file) { switch (file->f_mode & (FMODE_READ | FMODE_WRITE)) { @@ -214,7 +226,7 @@ int snd_rawmidi_drain_input(struct snd_rawmidi_substream *substream) return 0; } -int snd_rawmidi_kernel_open(int cardnum, int device, int subdevice, +int snd_rawmidi_kernel_open(struct snd_card *card, int device, int subdevice, int mode, struct snd_rawmidi_file * rfile) { struct snd_rawmidi *rmidi; @@ -225,7 +237,9 @@ int snd_rawmidi_kernel_open(int cardnum, int device, int subdevice, if (rfile) rfile->input = rfile->output = NULL; - rmidi = snd_rawmidi_devices[(cardnum * SNDRV_RAWMIDI_DEVICES) + device]; + down(®ister_mutex); + rmidi = snd_rawmidi_search(card, device); + up(®ister_mutex); if (rmidi == NULL) { err = -ENODEV; goto __error1; @@ -368,9 +382,8 @@ int snd_rawmidi_kernel_open(int cardnum, int device, int subdevice, static int snd_rawmidi_open(struct inode *inode, struct file *file) { int maj = imajor(inode); - int cardnum; struct snd_card *card; - int device, subdevice; + int subdevice; unsigned short fflags; int err; struct snd_rawmidi *rmidi; @@ -380,27 +393,18 @@ static int snd_rawmidi_open(struct inode *inode, struct file *file) struct snd_ctl_file *kctl; if (maj == snd_major) { - cardnum = SNDRV_MINOR_CARD(iminor(inode)); - cardnum %= SNDRV_CARDS; - device = SNDRV_MINOR_DEVICE(iminor(inode)) - SNDRV_MINOR_RAWMIDI; - device %= SNDRV_MINOR_RAWMIDIS; + rmidi = snd_lookup_minor_data(iminor(inode), + SNDRV_DEVICE_TYPE_RAWMIDI); #ifdef CONFIG_SND_OSSEMUL } else if (maj == SOUND_MAJOR) { - cardnum = SNDRV_MINOR_OSS_CARD(iminor(inode)); - cardnum %= SNDRV_CARDS; - device = SNDRV_MINOR_OSS_DEVICE(iminor(inode)) == SNDRV_MINOR_OSS_MIDI ? - midi_map[cardnum] : amidi_map[cardnum]; + rmidi = snd_lookup_oss_minor_data(iminor(inode), + SNDRV_OSS_DEVICE_TYPE_MIDI); #endif } else return -ENXIO; - rmidi = snd_rawmidi_devices[(cardnum * SNDRV_RAWMIDI_DEVICES) + device]; if (rmidi == NULL) return -ENODEV; -#ifdef CONFIG_SND_OSSEMUL - if (maj == SOUND_MAJOR && !rmidi->ossreg) - return -ENXIO; -#endif if ((file->f_flags & O_APPEND) && !(file->f_flags & O_NONBLOCK)) return -EINVAL; /* invalid combination */ card = rmidi->card; @@ -430,7 +434,8 @@ static int snd_rawmidi_open(struct inode *inode, struct file *file) } } up_read(&card->controls_rwsem); - err = snd_rawmidi_kernel_open(cardnum, device, subdevice, fflags, rawmidi_file); + err = snd_rawmidi_kernel_open(rmidi->card, rmidi->device, + subdevice, fflags, rawmidi_file); if (err >= 0) break; if (err == -EAGAIN) { @@ -570,9 +575,10 @@ int snd_rawmidi_info_select(struct snd_card *card, struct snd_rawmidi_info *info struct snd_rawmidi_str *pstr; struct snd_rawmidi_substream *substream; struct list_head *list; - if (info->device >= SNDRV_RAWMIDI_DEVICES) - return -ENXIO; - rmidi = snd_rawmidi_devices[card->number * SNDRV_RAWMIDI_DEVICES + info->device]; + + down(®ister_mutex); + rmidi = snd_rawmidi_search(card, info->device); + up(®ister_mutex); if (!rmidi) return -ENXIO; if (info->stream < 0 || info->stream > 1) @@ -803,9 +809,7 @@ static int snd_rawmidi_control_ioctl(struct snd_card *card, unsigned long arg) { void __user *argp = (void __user *)arg; - unsigned int tmp; - tmp = card->number * SNDRV_RAWMIDI_DEVICES; switch (cmd) { case SNDRV_CTL_IOCTL_RAWMIDI_NEXT_DEVICE: { @@ -813,14 +817,16 @@ static int snd_rawmidi_control_ioctl(struct snd_card *card, if (get_user(device, (int __user *)argp)) return -EFAULT; + down(®ister_mutex); device = device < 0 ? 0 : device + 1; while (device < SNDRV_RAWMIDI_DEVICES) { - if (snd_rawmidi_devices[tmp + device]) + if (snd_rawmidi_search(card, device)) break; device++; } if (device == SNDRV_RAWMIDI_DEVICES) device = -1; + up(®ister_mutex); if (put_user(device, (int __user *)argp)) return -EFAULT; return 0; @@ -1493,7 +1499,7 @@ static void snd_rawmidi_dev_seq_free(struct snd_seq_device *device) static int snd_rawmidi_dev_register(struct snd_device *device) { - int idx, err; + int err; struct snd_info_entry *entry; char name[16]; struct snd_rawmidi *rmidi = device->device_data; @@ -1501,25 +1507,24 @@ static int snd_rawmidi_dev_register(struct snd_device *device) if (rmidi->device >= SNDRV_RAWMIDI_DEVICES) return -ENOMEM; down(®ister_mutex); - idx = (rmidi->card->number * SNDRV_RAWMIDI_DEVICES) + rmidi->device; - if (snd_rawmidi_devices[idx] != NULL) { + if (snd_rawmidi_search(rmidi->card, rmidi->device)) { up(®ister_mutex); return -EBUSY; } - snd_rawmidi_devices[idx] = rmidi; + list_add_tail(&rmidi->list, &snd_rawmidi_devices); sprintf(name, "midiC%iD%i", rmidi->card->number, rmidi->device); if ((err = snd_register_device(SNDRV_DEVICE_TYPE_RAWMIDI, rmidi->card, rmidi->device, - &snd_rawmidi_f_ops, name)) < 0) { + &snd_rawmidi_f_ops, rmidi, name)) < 0) { snd_printk(KERN_ERR "unable to register rawmidi device %i:%i\n", rmidi->card->number, rmidi->device); - snd_rawmidi_devices[idx] = NULL; + list_del(&rmidi->list); up(®ister_mutex); return err; } if (rmidi->ops && rmidi->ops->dev_register && (err = rmidi->ops->dev_register(rmidi)) < 0) { snd_unregister_device(SNDRV_DEVICE_TYPE_RAWMIDI, rmidi->card, rmidi->device); - snd_rawmidi_devices[idx] = NULL; + list_del(&rmidi->list); up(®ister_mutex); return err; } @@ -1527,8 +1532,8 @@ static int snd_rawmidi_dev_register(struct snd_device *device) rmidi->ossreg = 0; if ((int)rmidi->device == midi_map[rmidi->card->number]) { if (snd_register_oss_device(SNDRV_OSS_DEVICE_TYPE_MIDI, - rmidi->card, 0, - &snd_rawmidi_f_ops, name) < 0) { + rmidi->card, 0, &snd_rawmidi_f_ops, + rmidi, name) < 0) { snd_printk(KERN_ERR "unable to register OSS rawmidi device %i:%i\n", rmidi->card->number, 0); } else { rmidi->ossreg++; @@ -1539,8 +1544,8 @@ static int snd_rawmidi_dev_register(struct snd_device *device) } if ((int)rmidi->device == amidi_map[rmidi->card->number]) { if (snd_register_oss_device(SNDRV_OSS_DEVICE_TYPE_MIDI, - rmidi->card, 1, - &snd_rawmidi_f_ops, name) < 0) { + rmidi->card, 1, &snd_rawmidi_f_ops, + rmidi, name) < 0) { snd_printk(KERN_ERR "unable to register OSS rawmidi device %i:%i\n", rmidi->card->number, 1); } else { rmidi->ossreg++; @@ -1576,24 +1581,20 @@ static int snd_rawmidi_dev_register(struct snd_device *device) static int snd_rawmidi_dev_disconnect(struct snd_device *device) { struct snd_rawmidi *rmidi = device->device_data; - int idx; down(®ister_mutex); - idx = (rmidi->card->number * SNDRV_RAWMIDI_DEVICES) + rmidi->device; - snd_rawmidi_devices[idx] = NULL; + list_del_init(&rmidi->list); up(®ister_mutex); return 0; } static int snd_rawmidi_dev_unregister(struct snd_device *device) { - int idx; struct snd_rawmidi *rmidi = device->device_data; snd_assert(rmidi != NULL, return -ENXIO); down(®ister_mutex); - idx = (rmidi->card->number * SNDRV_RAWMIDI_DEVICES) + rmidi->device; - snd_rawmidi_devices[idx] = NULL; + list_del(&rmidi->list); if (rmidi->proc_entry) { snd_info_unregister(rmidi->proc_entry); rmidi->proc_entry = NULL; diff --git a/sound/core/seq/oss/seq_oss.c b/sound/core/seq/oss/seq_oss.c index 61c0a41376fd..4b51ab56507b 100644 --- a/sound/core/seq/oss/seq_oss.c +++ b/sound/core/seq/oss/seq_oss.c @@ -225,7 +225,7 @@ register_device(void) down(®ister_mutex); if ((rc = snd_register_oss_device(SNDRV_OSS_DEVICE_TYPE_SEQUENCER, NULL, 0, - &seq_oss_f_ops, + &seq_oss_f_ops, NULL, SNDRV_SEQ_OSS_DEVNAME)) < 0) { snd_printk(KERN_ERR "can't register device seq\n"); up(®ister_mutex); @@ -233,7 +233,7 @@ register_device(void) } if ((rc = snd_register_oss_device(SNDRV_OSS_DEVICE_TYPE_MUSIC, NULL, 0, - &seq_oss_f_ops, + &seq_oss_f_ops, NULL, SNDRV_SEQ_OSS_DEVNAME)) < 0) { snd_printk(KERN_ERR "can't register device music\n"); snd_unregister_oss_device(SNDRV_OSS_DEVICE_TYPE_SEQUENCER, NULL, 0); diff --git a/sound/core/seq/seq_clientmgr.c b/sound/core/seq/seq_clientmgr.c index 087fdf32732b..c8bd37ee8375 100644 --- a/sound/core/seq/seq_clientmgr.c +++ b/sound/core/seq/seq_clientmgr.c @@ -2531,7 +2531,7 @@ int __init snd_sequencer_device_init(void) return -ERESTARTSYS; if ((err = snd_register_device(SNDRV_DEVICE_TYPE_SEQUENCER, NULL, 0, - &snd_seq_f_ops, "seq")) < 0) { + &snd_seq_f_ops, NULL, "seq")) < 0) { up(®ister_mutex); return err; } diff --git a/sound/core/seq/seq_midi.c b/sound/core/seq/seq_midi.c index f88d2e3ee66e..0a65eb2f976b 100644 --- a/sound/core/seq/seq_midi.c +++ b/sound/core/seq/seq_midi.c @@ -183,7 +183,10 @@ static int midisynth_subscribe(void *private_data, struct snd_seq_port_subscribe 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) { + if ((err = snd_rawmidi_kernel_open(msynth->card, msynth->device, + msynth->subdevice, + SNDRV_RAWMIDI_LFLG_INPUT, + &msynth->input_rfile)) < 0) { snd_printd("midi input open failed!!!\n"); return err; } @@ -221,7 +224,10 @@ static int midisynth_use(void *private_data, struct snd_seq_port_subscribe *info 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) { + if ((err = snd_rawmidi_kernel_open(msynth->card, msynth->device, + msynth->subdevice, + SNDRV_RAWMIDI_LFLG_OUTPUT, + &msynth->output_rfile)) < 0) { snd_printd("midi output open failed!!!\n"); return err; } diff --git a/sound/core/sound.c b/sound/core/sound.c index a509f49fa0b4..1e5eca546925 100644 --- a/sound/core/sound.c +++ b/sound/core/sound.c @@ -60,7 +60,6 @@ MODULE_ALIAS_CHARDEV_MAJOR(CONFIG_SND_MAJOR); int snd_ecards_limit; static struct snd_minor *snd_minors[SNDRV_OS_MINORS]; - static DECLARE_MUTEX(sound_mutex); extern struct class *sound_class; @@ -107,6 +106,31 @@ static void snd_request_other(int minor) #endif /* request_module support */ +/** + * snd_lookup_minor_data - get user data of a registered device + * @minor: the minor number + * @type: device type (SNDRV_DEVICE_TYPE_XXX) + * + * Checks that a minor device with the specified type is registered, and returns + * its user data pointer. + */ +void *snd_lookup_minor_data(unsigned int minor, int type) +{ + struct snd_minor *mreg; + void *private_data; + + if (minor > ARRAY_SIZE(snd_minors)) + return NULL; + down(&sound_mutex); + mreg = snd_minors[minor]; + if (mreg && mreg->type == type) + private_data = mreg->private_data; + else + private_data = NULL; + up(&sound_mutex); + return private_data; +} + static int snd_open(struct inode *inode, struct file *file) { int minor = iminor(inode); @@ -183,6 +207,7 @@ static int snd_kernel_minor(int type, struct snd_card *card, int dev) * @card: the card instance * @dev: the device index * @f_ops: the file operations + * @private_data: user pointer for f_ops->open() * @name: the device file name * * Registers an ALSA device file for the given card. @@ -191,7 +216,8 @@ static int snd_kernel_minor(int type, struct snd_card *card, int dev) * Retrurns zero if successful, or a negative error code on failure. */ int snd_register_device(int type, struct snd_card *card, int dev, - struct file_operations *f_ops, const char *name) + struct file_operations *f_ops, void *private_data, + const char *name) { int minor = snd_kernel_minor(type, card, dev); struct snd_minor *preg; @@ -207,6 +233,7 @@ int snd_register_device(int type, struct snd_card *card, int dev, preg->card = card ? card->number : -1; preg->device = dev; preg->f_ops = f_ops; + preg->private_data = private_data; strcpy(preg->name, name); down(&sound_mutex); if (snd_minors[minor]) { @@ -238,13 +265,18 @@ int snd_register_device(int type, struct snd_card *card, int dev, */ int snd_unregister_device(int type, struct snd_card *card, int dev) { - int minor = snd_kernel_minor(type, card, dev); + int cardnum, minor; struct snd_minor *mptr; - if (minor < 0) - return minor; + cardnum = card ? card->number : -1; down(&sound_mutex); - if ((mptr = snd_minors[minor]) == NULL) { + for (minor = 0; minor < ARRAY_SIZE(snd_minors); ++minor) + if ((mptr = snd_minors[minor]) != NULL && + mptr->type == type && + mptr->card == cardnum && + mptr->device == dev) + break; + if (minor == ARRAY_SIZE(snd_minors)) { up(&sound_mutex); return -EINVAL; } @@ -392,9 +424,11 @@ EXPORT_SYMBOL(snd_request_card); #endif EXPORT_SYMBOL(snd_register_device); EXPORT_SYMBOL(snd_unregister_device); +EXPORT_SYMBOL(snd_lookup_minor_data); #if defined(CONFIG_SND_OSSEMUL) EXPORT_SYMBOL(snd_register_oss_device); EXPORT_SYMBOL(snd_unregister_oss_device); +EXPORT_SYMBOL(snd_lookup_oss_minor_data); #endif /* memory.c */ EXPORT_SYMBOL(copy_to_user_fromio); diff --git a/sound/core/sound_oss.c b/sound/core/sound_oss.c index afbfd8df1298..b9e89cac4c5d 100644 --- a/sound/core/sound_oss.c +++ b/sound/core/sound_oss.c @@ -38,9 +38,25 @@ #define SNDRV_OSS_MINORS 128 static struct snd_minor *snd_oss_minors[SNDRV_OSS_MINORS]; - static DECLARE_MUTEX(sound_oss_mutex); +void *snd_lookup_oss_minor_data(unsigned int minor, int type) +{ + struct snd_minor *mreg; + void *private_data; + + if (minor > ARRAY_SIZE(snd_oss_minors)) + return NULL; + down(&sound_oss_mutex); + mreg = snd_oss_minors[minor]; + if (mreg && mreg->type == type) + private_data = mreg->private_data; + else + private_data = NULL; + up(&sound_oss_mutex); + return private_data; +} + static int snd_oss_kernel_minor(int type, struct snd_card *card, int dev) { int minor; @@ -78,7 +94,8 @@ static int snd_oss_kernel_minor(int type, struct snd_card *card, int dev) } int snd_register_oss_device(int type, struct snd_card *card, int dev, - struct file_operations *f_ops, const char *name) + struct file_operations *f_ops, void *private_data, + const char *name) { int minor = snd_oss_kernel_minor(type, card, dev); int minor_unit; @@ -97,6 +114,7 @@ int snd_register_oss_device(int type, struct snd_card *card, int dev, preg->card = card ? card->number : -1; preg->device = dev; preg->f_ops = f_ops; + preg->private_data = private_data; down(&sound_oss_mutex); snd_oss_minors[minor] = preg; minor_unit = SNDRV_MINOR_OSS_DEVICE(minor); @@ -121,6 +139,7 @@ int snd_register_oss_device(int type, struct snd_card *card, int dev, carddev); if (register2 != track2) goto __end; + snd_oss_minors[track2] = preg; } up(&sound_oss_mutex); return 0; @@ -163,8 +182,10 @@ int snd_unregister_oss_device(int type, struct snd_card *card, int dev) track2 = SNDRV_MINOR_OSS(cidx, SNDRV_MINOR_OSS_DMMIDI1); break; } - if (track2 >= 0) + if (track2 >= 0) { unregister_sound_special(track2); + snd_oss_minors[track2] = NULL; + } snd_oss_minors[minor] = NULL; up(&sound_oss_mutex); kfree(mptr); diff --git a/sound/core/timer.c b/sound/core/timer.c index a7bcb04263cb..c62dbacdca13 100644 --- a/sound/core/timer.c +++ b/sound/core/timer.c @@ -1952,8 +1952,8 @@ static int __init alsa_timer_init(void) if ((err = snd_timer_register_system()) < 0) snd_printk(KERN_ERR "unable to register system timer (%i)\n", err); - if ((err = snd_register_device(SNDRV_DEVICE_TYPE_TIMER, - NULL, 0, &snd_timer_f_ops, "timer")) < 0) + if ((err = snd_register_device(SNDRV_DEVICE_TYPE_TIMER, NULL, 0, + &snd_timer_f_ops, NULL, "timer")) < 0) snd_printk(KERN_ERR "unable to register timer device (%i)\n", err); return 0; -- cgit v1.2.3 From 04f141a8800d022981f0405a8d307c98aba55105 Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Thu, 1 Dec 2005 10:43:51 +0100 Subject: [ALSA] Optimize for config without PROC_FS (seq and oss parts) Modules: ALSA<-OSS emulation,ALSA sequencer,ALSA<-OSS sequencer Optimize the code when compiled without CONFIG_PROC_FS (in seq and oss emulation parts). Signed-off-by: Takashi Iwai --- sound/core/oss/mixer_oss.c | 5 +++++ sound/core/oss/pcm_oss.c | 5 +++++ sound/core/seq/oss/seq_oss.c | 14 ++++++-------- sound/core/seq/oss/seq_oss_init.c | 3 ++- sound/core/seq/oss/seq_oss_midi.c | 3 ++- sound/core/seq/oss/seq_oss_readq.c | 2 ++ sound/core/seq/oss/seq_oss_synth.c | 3 ++- sound/core/seq/seq_clientmgr.c | 3 ++- sound/core/seq/seq_device.c | 8 ++++++++ sound/core/seq/seq_info.c | 13 +++++-------- sound/core/seq/seq_info.h | 6 +++++- sound/core/seq/seq_queue.c | 3 +++ sound/core/seq/seq_timer.c | 3 +++ 13 files changed, 50 insertions(+), 21 deletions(-) (limited to 'sound/core/oss/mixer_oss.c') diff --git a/sound/core/oss/mixer_oss.c b/sound/core/oss/mixer_oss.c index 2d7a42014f51..f08e65a2bffe 100644 --- a/sound/core/oss/mixer_oss.c +++ b/sound/core/oss/mixer_oss.c @@ -1053,6 +1053,7 @@ static int snd_mixer_oss_build_input(struct snd_mixer_oss *mixer, struct snd_mix return 0; } +#ifdef CONFIG_PROC_FS /* */ #define MIXER_VOL(name) [SOUND_MIXER_##name] = #name @@ -1200,6 +1201,10 @@ static void snd_mixer_oss_proc_done(struct snd_mixer_oss *mixer) mixer->proc_entry = NULL; } } +#else /* !CONFIG_PROC_FS */ +#define snd_mixer_oss_proc_init(mix) +#define snd_mixer_oss_proc_done(mix) +#endif /* CONFIG_PROC_FS */ static void snd_mixer_oss_build(struct snd_mixer_oss *mixer) { diff --git a/sound/core/oss/pcm_oss.c b/sound/core/oss/pcm_oss.c index 2ae283c7b28a..16df1246a131 100644 --- a/sound/core/oss/pcm_oss.c +++ b/sound/core/oss/pcm_oss.c @@ -2269,6 +2269,7 @@ static int snd_pcm_oss_mmap(struct file *file, struct vm_area_struct *area) return 0; } +#ifdef CONFIG_PROC_FS /* * /proc interface */ @@ -2420,6 +2421,10 @@ static void snd_pcm_oss_proc_done(struct snd_pcm *pcm) } } } +#else /* !CONFIG_PROC_FS */ +#define snd_pcm_oss_proc_init(pcm) +#define snd_pcm_oss_proc_done(pcm) +#endif /* CONFIG_PROC_FS */ /* * ENTRY functions diff --git a/sound/core/seq/oss/seq_oss.c b/sound/core/seq/oss/seq_oss.c index 4b51ab56507b..c98f0ba13810 100644 --- a/sound/core/seq/oss/seq_oss.c +++ b/sound/core/seq/oss/seq_oss.c @@ -52,8 +52,13 @@ int seq_oss_debug = 0; */ static int register_device(void); static void unregister_device(void); +#ifdef CONFIG_PROC_FS static int register_proc(void); static void unregister_proc(void); +#else +static inline int register_proc(void) { return 0; } +static inline void unregister_proc(void) {} +#endif static int odev_open(struct inode *inode, struct file *file); static int odev_release(struct inode *inode, struct file *file); @@ -61,9 +66,6 @@ static ssize_t odev_read(struct file *file, char __user *buf, size_t count, loff static ssize_t odev_write(struct file *file, const char __user *buf, size_t count, loff_t *offset); static long odev_ioctl(struct file *file, unsigned int cmd, unsigned long arg); static unsigned int odev_poll(struct file *file, poll_table * wait); -#ifdef CONFIG_PROC_FS -static void info_read(struct snd_info_entry *entry, struct snd_info_buffer *buf); -#endif /* @@ -276,12 +278,10 @@ info_read(struct snd_info_entry *entry, struct snd_info_buffer *buf) up(®ister_mutex); } -#endif /* CONFIG_PROC_FS */ static int __init register_proc(void) { -#ifdef CONFIG_PROC_FS struct snd_info_entry *entry; entry = snd_info_create_module_entry(THIS_MODULE, SNDRV_SEQ_OSS_PROCNAME, snd_seq_root); @@ -297,16 +297,14 @@ register_proc(void) return -ENOMEM; } info_entry = entry; -#endif return 0; } static void unregister_proc(void) { -#ifdef CONFIG_PROC_FS if (info_entry) snd_info_unregister(info_entry); info_entry = NULL; -#endif } +#endif /* CONFIG_PROC_FS */ diff --git a/sound/core/seq/oss/seq_oss_init.c b/sound/core/seq/oss/seq_oss_init.c index 1d4473eadcf3..97e2493e931f 100644 --- a/sound/core/seq/oss/seq_oss_init.c +++ b/sound/core/seq/oss/seq_oss_init.c @@ -502,6 +502,7 @@ snd_seq_oss_reset(struct seq_oss_devinfo *dp) } +#ifdef CONFIG_PROC_FS /* * misc. functions for proc interface */ @@ -552,4 +553,4 @@ snd_seq_oss_system_info_read(struct snd_info_buffer *buf) snd_seq_oss_readq_info_read(dp->readq, buf); } } - +#endif /* CONFIG_PROC_FS */ diff --git a/sound/core/seq/oss/seq_oss_midi.c b/sound/core/seq/oss/seq_oss_midi.c index eb7ae990965c..0a711d2d04f0 100644 --- a/sound/core/seq/oss/seq_oss_midi.c +++ b/sound/core/seq/oss/seq_oss_midi.c @@ -668,6 +668,7 @@ snd_seq_oss_midi_make_info(struct seq_oss_devinfo *dp, int dev, struct midi_info } +#ifdef CONFIG_PROC_FS /* * proc interface */ @@ -707,4 +708,4 @@ snd_seq_oss_midi_info_read(struct snd_info_buffer *buf) snd_use_lock_free(&mdev->use_lock); } } - +#endif /* CONFIG_PROC_FS */ diff --git a/sound/core/seq/oss/seq_oss_readq.c b/sound/core/seq/oss/seq_oss_readq.c index abc70078add3..f5de79f29f1e 100644 --- a/sound/core/seq/oss/seq_oss_readq.c +++ b/sound/core/seq/oss/seq_oss_readq.c @@ -222,6 +222,7 @@ snd_seq_oss_readq_put_timestamp(struct seq_oss_readq *q, unsigned long curt, int } +#ifdef CONFIG_PROC_FS /* * proc interface */ @@ -232,3 +233,4 @@ snd_seq_oss_readq_info_read(struct seq_oss_readq *q, struct snd_info_buffer *buf (waitqueue_active(&q->midi_sleep) ? "sleeping":"running"), q->qlen, q->input_time); } +#endif /* CONFIG_PROC_FS */ diff --git a/sound/core/seq/oss/seq_oss_synth.c b/sound/core/seq/oss/seq_oss_synth.c index 0b6025c92b9e..ab570a0a6183 100644 --- a/sound/core/seq/oss/seq_oss_synth.c +++ b/sound/core/seq/oss/seq_oss_synth.c @@ -621,6 +621,7 @@ snd_seq_oss_synth_make_info(struct seq_oss_devinfo *dp, int dev, struct synth_in } +#ifdef CONFIG_PROC_FS /* * proc interface */ @@ -648,4 +649,4 @@ snd_seq_oss_synth_info_read(struct snd_info_buffer *buf) snd_use_lock_free(&rec->use_lock); } } - +#endif /* CONFIG_PROC_FS */ diff --git a/sound/core/seq/seq_clientmgr.c b/sound/core/seq/seq_clientmgr.c index 2a9c6b316b14..9c32fd262f8d 100644 --- a/sound/core/seq/seq_clientmgr.c +++ b/sound/core/seq/seq_clientmgr.c @@ -2413,6 +2413,7 @@ int snd_seq_kernel_client_write_poll(int clientid, struct file *file, poll_table /*---------------------------------------------------------------------------*/ +#ifdef CONFIG_PROC_FS /* * /proc interface */ @@ -2518,7 +2519,7 @@ void snd_seq_info_clients_read(struct snd_info_entry *entry, snd_seq_client_unlock(client); } } - +#endif /* CONFIG_PROC_FS */ /*---------------------------------------------------------------------------*/ diff --git a/sound/core/seq/seq_device.c b/sound/core/seq/seq_device.c index 3f935a18b5e7..9ece443fba55 100644 --- a/sound/core/seq/seq_device.c +++ b/sound/core/seq/seq_device.c @@ -78,7 +78,9 @@ struct ops_list { static LIST_HEAD(opslist); static int num_ops; static DECLARE_MUTEX(ops_mutex); +#ifdef CONFIG_PROC_FS static struct snd_info_entry *info_entry = NULL; +#endif /* * prototypes @@ -100,6 +102,7 @@ static void remove_drivers(void); * show all drivers and their status */ +#ifdef CONFIG_PROC_FS static void snd_seq_device_info(struct snd_info_entry *entry, struct snd_info_buffer *buffer) { @@ -117,6 +120,7 @@ static void snd_seq_device_info(struct snd_info_entry *entry, } up(&ops_mutex); } +#endif /* * load all registered drivers (called from seq_clientmgr.c) @@ -544,6 +548,7 @@ static void unlock_driver(struct ops_list *ops) static int __init alsa_seq_device_init(void) { +#ifdef CONFIG_PROC_FS info_entry = snd_info_create_module_entry(THIS_MODULE, "drivers", snd_seq_root); if (info_entry == NULL) @@ -555,13 +560,16 @@ static int __init alsa_seq_device_init(void) snd_info_free_entry(info_entry); return -ENOMEM; } +#endif return 0; } static void __exit alsa_seq_device_exit(void) { remove_drivers(); +#ifdef CONFIG_PROC_FS snd_info_unregister(info_entry); +#endif if (num_ops) snd_printk(KERN_ERR "drivers not released (%d)\n", num_ops); } diff --git a/sound/core/seq/seq_info.c b/sound/core/seq/seq_info.c index 3257cf4ec258..acce21afdaa4 100644 --- a/sound/core/seq/seq_info.c +++ b/sound/core/seq/seq_info.c @@ -27,7 +27,7 @@ #include "seq_clientmgr.h" #include "seq_timer.h" - +#ifdef CONFIG_PROC_FS static struct snd_info_entry *queues_entry; static struct snd_info_entry *clients_entry; static struct snd_info_entry *timer_entry; @@ -52,7 +52,6 @@ create_info_entry(char *name, int size, void (*read)(struct snd_info_entry *, return entry; } - /* create all our /proc entries */ int __init snd_seq_info_init(void) { @@ -66,11 +65,9 @@ int __init snd_seq_info_init(void) int __exit snd_seq_info_done(void) { - if (queues_entry) - snd_info_unregister(queues_entry); - if (clients_entry) - snd_info_unregister(clients_entry); - if (timer_entry) - snd_info_unregister(timer_entry); + snd_info_unregister(queues_entry); + snd_info_unregister(clients_entry); + snd_info_unregister(timer_entry); return 0; } +#endif diff --git a/sound/core/seq/seq_info.h b/sound/core/seq/seq_info.h index 5a91ebce43a0..4892a7f35c08 100644 --- a/sound/core/seq/seq_info.h +++ b/sound/core/seq/seq_info.h @@ -29,8 +29,12 @@ void snd_seq_info_timer_read(struct snd_info_entry *entry, struct snd_info_buffe void snd_seq_info_queues_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer); +#ifdef CONFIG_PROC_FS int snd_seq_info_init( void ); int snd_seq_info_done( void ); - +#else +static inline int snd_seq_info_init(void) { return 0; } +static inline int snd_seq_info_done(void) { return 0; } +#endif #endif diff --git a/sound/core/seq/seq_queue.c b/sound/core/seq/seq_queue.c index b537a71e1e19..9cf20f045542 100644 --- a/sound/core/seq/seq_queue.c +++ b/sound/core/seq/seq_queue.c @@ -756,6 +756,7 @@ int snd_seq_control_queue(struct snd_seq_event *ev, int atomic, int hop) /*----------------------------------------------------------------*/ +#ifdef CONFIG_PROC_FS /* exported to seq_info.c */ void snd_seq_info_queues_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer) @@ -789,3 +790,5 @@ void snd_seq_info_queues_read(struct snd_info_entry *entry, queuefree(q); } } +#endif /* CONFIG_PROC_FS */ + diff --git a/sound/core/seq/seq_timer.c b/sound/core/seq/seq_timer.c index a1d8bfd60ae9..b4b9a132cb16 100644 --- a/sound/core/seq/seq_timer.c +++ b/sound/core/seq/seq_timer.c @@ -425,6 +425,7 @@ snd_seq_tick_time_t snd_seq_timer_get_cur_tick(struct snd_seq_timer *tmr) } +#ifdef CONFIG_PROC_FS /* exported to seq_info.c */ void snd_seq_info_timer_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer) @@ -451,3 +452,5 @@ void snd_seq_info_timer_read(struct snd_info_entry *entry, queuefree(q); } } +#endif /* CONFIG_PROC_FS */ + -- cgit v1.2.3