diff options
Diffstat (limited to 'sound/core')
82 files changed, 4458 insertions, 4372 deletions
diff --git a/sound/core/Kconfig b/sound/core/Kconfig index 82718836f93..f79755f77a8 100644 --- a/sound/core/Kconfig +++ b/sound/core/Kconfig @@ -111,6 +111,25 @@ config SND_SEQ_RTCTIMER_DEFAULT If in doubt, say Y. +config SND_DYNAMIC_MINORS + bool "Dynamic device file minor numbers (EXPERIMENTAL)" + depends on SND && EXPERIMENTAL + help + If you say Y here, the minor numbers of ALSA device files in + /dev/snd/ are allocated dynamically. This allows you to have + more than 8 sound cards, but requires a dynamic device file + system like udev. + + If you are unsure about this, say N here. + +config SND_SUPPORT_OLD_API + bool "Support old ALSA API" + depends on SND + default y + help + Say Y here to support the obsolete ALSA PCM API (ver.0.9.0 rc3 + or older). + config SND_VERBOSE_PRINTK bool "Verbose printk" depends on SND @@ -133,7 +152,3 @@ config SND_DEBUG_DETECT help Say Y here to enable extra-verbose log messages printed when detecting devices. - -config SND_GENERIC_DRIVER - bool - depends on SND diff --git a/sound/core/control.c b/sound/core/control.c index 212c46a9437..abd62f94372 100644 --- a/sound/core/control.c +++ b/sound/core/control.c @@ -34,12 +34,10 @@ /* max number of user-defined controls */ #define MAX_USER_CONTROLS 32 -typedef struct _snd_kctl_ioctl { +struct snd_kctl_ioctl { struct list_head list; /* list of all ioctls */ snd_kctl_ioctl_func_t fioctl; -} snd_kctl_ioctl_t; - -#define snd_kctl_ioctl(n) list_entry(n, snd_kctl_ioctl_t, list) +}; static DECLARE_RWSEM(snd_ioctl_rwsem); static LIST_HEAD(snd_control_ioctls); @@ -49,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; - snd_card_t *card; - snd_ctl_file_t *ctl; + 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; @@ -93,9 +90,9 @@ static int snd_ctl_open(struct inode *inode, struct file *file) return err; } -static void snd_ctl_empty_read_queue(snd_ctl_file_t * ctl) +static void snd_ctl_empty_read_queue(struct snd_ctl_file * ctl) { - snd_kctl_event_t *cread; + struct snd_kctl_event *cread; spin_lock(&ctl->read_lock); while (!list_empty(&ctl->events)) { @@ -110,9 +107,9 @@ static int snd_ctl_release(struct inode *inode, struct file *file) { unsigned long flags; struct list_head *list; - snd_card_t *card; - snd_ctl_file_t *ctl; - snd_kcontrol_t *control; + struct snd_card *card; + struct snd_ctl_file *ctl; + struct snd_kcontrol *control; unsigned int idx; ctl = file->private_data; @@ -137,12 +134,13 @@ static int snd_ctl_release(struct inode *inode, struct file *file) return 0; } -void snd_ctl_notify(snd_card_t *card, unsigned int mask, snd_ctl_elem_id_t *id) +void snd_ctl_notify(struct snd_card *card, unsigned int mask, + struct snd_ctl_elem_id *id) { unsigned long flags; struct list_head *flist; - snd_ctl_file_t *ctl; - snd_kctl_event_t *ev; + struct snd_ctl_file *ctl; + struct snd_kctl_event *ev; snd_assert(card != NULL && id != NULL, return); read_lock(&card->ctl_files_rwlock); @@ -183,21 +181,23 @@ void snd_ctl_notify(snd_card_t *card, unsigned int mask, snd_ctl_elem_id_t *id) * @control: the control template * @access: the default control access * - * Allocates a new snd_kcontrol_t instance and copies the given template + * Allocates a new struct snd_kcontrol instance and copies the given template * to the new instance. It does not copy volatile data (access). * * Returns the pointer of the new instance, or NULL on failure. */ -snd_kcontrol_t *snd_ctl_new(snd_kcontrol_t * control, unsigned int access) +struct snd_kcontrol *snd_ctl_new(struct snd_kcontrol *control, unsigned int access) { - snd_kcontrol_t *kctl; + struct snd_kcontrol *kctl; unsigned int idx; snd_assert(control != NULL, return NULL); snd_assert(control->count > 0, return NULL); - kctl = kzalloc(sizeof(*kctl) + sizeof(snd_kcontrol_volatile_t) * control->count, GFP_KERNEL); - if (kctl == NULL) + kctl = kzalloc(sizeof(*kctl) + sizeof(struct snd_kcontrol_volatile) * control->count, GFP_KERNEL); + if (kctl == NULL) { + snd_printk(KERN_ERR "Cannot allocate control instance\n"); return NULL; + } *kctl = *control; for (idx = 0; idx < kctl->count; idx++) kctl->vd[idx].access = access; @@ -209,15 +209,16 @@ snd_kcontrol_t *snd_ctl_new(snd_kcontrol_t * control, unsigned int access) * @ncontrol: the initialization record * @private_data: the private data to set * - * Allocates a new snd_kcontrol_t instance and initialize from the given + * Allocates a new struct snd_kcontrol instance and initialize from the given * template. When the access field of ncontrol is 0, it's assumed as * READWRITE access. When the count field is 0, it's assumes as one. * * Returns the pointer of the newly generated instance, or NULL on failure. */ -snd_kcontrol_t *snd_ctl_new1(const snd_kcontrol_new_t * ncontrol, void *private_data) +struct snd_kcontrol *snd_ctl_new1(const struct snd_kcontrol_new *ncontrol, + void *private_data) { - snd_kcontrol_t kctl; + struct snd_kcontrol kctl; unsigned int access; snd_assert(ncontrol != NULL, return NULL); @@ -249,7 +250,7 @@ snd_kcontrol_t *snd_ctl_new1(const snd_kcontrol_new_t * ncontrol, void *private_ * or snd_ctl_new1(). * Don't call this after the control was added to the card. */ -void snd_ctl_free_one(snd_kcontrol_t * kcontrol) +void snd_ctl_free_one(struct snd_kcontrol *kcontrol) { if (kcontrol) { if (kcontrol->private_free) @@ -258,11 +259,11 @@ void snd_ctl_free_one(snd_kcontrol_t * kcontrol) } } -static unsigned int snd_ctl_hole_check(snd_card_t * card, +static unsigned int snd_ctl_hole_check(struct snd_card *card, unsigned int count) { struct list_head *list; - snd_kcontrol_t *kctl; + struct snd_kcontrol *kctl; list_for_each(list, &card->controls) { kctl = snd_kcontrol(list); @@ -275,7 +276,7 @@ static unsigned int snd_ctl_hole_check(snd_card_t * card, return card->last_numid; } -static int snd_ctl_find_hole(snd_card_t * card, unsigned int count) +static int snd_ctl_find_hole(struct snd_card *card, unsigned int count) { unsigned int last_numid, iter = 100000; @@ -304,12 +305,14 @@ static int snd_ctl_find_hole(snd_card_t * card, unsigned int count) * * It frees automatically the control which cannot be added. */ -int snd_ctl_add(snd_card_t * card, snd_kcontrol_t * kcontrol) +int snd_ctl_add(struct snd_card *card, struct snd_kcontrol *kcontrol) { - snd_ctl_elem_id_t id; + struct snd_ctl_elem_id id; unsigned int idx; - snd_assert(card != NULL && kcontrol != NULL, return -EINVAL); + snd_assert(card != NULL, return -EINVAL); + if (! kcontrol) + return -EINVAL; snd_assert(kcontrol->info != NULL, return -EINVAL); id = kcontrol->id; down_write(&card->controls_rwsem); @@ -350,9 +353,9 @@ int snd_ctl_add(snd_card_t * card, snd_kcontrol_t * kcontrol) * * Returns 0 if successful, or a negative error code on failure. */ -int snd_ctl_remove(snd_card_t * card, snd_kcontrol_t * kcontrol) +int snd_ctl_remove(struct snd_card *card, struct snd_kcontrol *kcontrol) { - snd_ctl_elem_id_t id; + struct snd_ctl_elem_id id; unsigned int idx; snd_assert(card != NULL && kcontrol != NULL, return -EINVAL); @@ -375,9 +378,9 @@ int snd_ctl_remove(snd_card_t * card, snd_kcontrol_t * kcontrol) * * Returns 0 if successful, or a negative error code on failure. */ -int snd_ctl_remove_id(snd_card_t * card, snd_ctl_elem_id_t *id) +int snd_ctl_remove_id(struct snd_card *card, struct snd_ctl_elem_id *id) { - snd_kcontrol_t *kctl; + struct snd_kcontrol *kctl; int ret; down_write(&card->controls_rwsem); @@ -401,10 +404,11 @@ int snd_ctl_remove_id(snd_card_t * card, snd_ctl_elem_id_t *id) * * Returns 0 if successful, or a negative error code on failure. */ -static int snd_ctl_remove_unlocked_id(snd_ctl_file_t * file, snd_ctl_elem_id_t *id) +static int snd_ctl_remove_unlocked_id(struct snd_ctl_file * file, + struct snd_ctl_elem_id *id) { - snd_card_t *card = file->card; - snd_kcontrol_t *kctl; + struct snd_card *card = file->card; + struct snd_kcontrol *kctl; int idx, ret; down_write(&card->controls_rwsem); @@ -434,9 +438,10 @@ static int snd_ctl_remove_unlocked_id(snd_ctl_file_t * file, snd_ctl_elem_id_t * * * Returns zero if successful, or a negative error code on failure. */ -int snd_ctl_rename_id(snd_card_t * card, snd_ctl_elem_id_t *src_id, snd_ctl_elem_id_t *dst_id) +int snd_ctl_rename_id(struct snd_card *card, struct snd_ctl_elem_id *src_id, + struct snd_ctl_elem_id *dst_id) { - snd_kcontrol_t *kctl; + struct snd_kcontrol *kctl; down_write(&card->controls_rwsem); kctl = snd_ctl_find_id(card, src_id); @@ -463,10 +468,10 @@ int snd_ctl_rename_id(snd_card_t * card, snd_ctl_elem_id_t *src_id, snd_ctl_elem * The caller must down card->controls_rwsem before calling this function * (if the race condition can happen). */ -snd_kcontrol_t *snd_ctl_find_numid(snd_card_t * card, unsigned int numid) +struct snd_kcontrol *snd_ctl_find_numid(struct snd_card *card, unsigned int numid) { struct list_head *list; - snd_kcontrol_t *kctl; + struct snd_kcontrol *kctl; snd_assert(card != NULL && numid != 0, return NULL); list_for_each(list, &card->controls) { @@ -489,10 +494,11 @@ snd_kcontrol_t *snd_ctl_find_numid(snd_card_t * card, unsigned int numid) * The caller must down card->controls_rwsem before calling this function * (if the race condition can happen). */ -snd_kcontrol_t *snd_ctl_find_id(snd_card_t * card, snd_ctl_elem_id_t *id) +struct snd_kcontrol *snd_ctl_find_id(struct snd_card *card, + struct snd_ctl_elem_id *id) { struct list_head *list; - snd_kcontrol_t *kctl; + struct snd_kcontrol *kctl; snd_assert(card != NULL && id != NULL, return NULL); if (id->numid != 0) @@ -516,10 +522,10 @@ snd_kcontrol_t *snd_ctl_find_id(snd_card_t * card, snd_ctl_elem_id_t *id) return NULL; } -static int snd_ctl_card_info(snd_card_t * card, snd_ctl_file_t * ctl, +static int snd_ctl_card_info(struct snd_card *card, struct snd_ctl_file * ctl, unsigned int cmd, void __user *arg) { - snd_ctl_card_info_t *info; + struct snd_ctl_card_info *info; info = kzalloc(sizeof(*info), GFP_KERNEL); if (! info) @@ -533,7 +539,7 @@ static int snd_ctl_card_info(snd_card_t * card, snd_ctl_file_t * ctl, strlcpy(info->mixername, card->mixername, sizeof(info->mixername)); strlcpy(info->components, card->components, sizeof(info->components)); up_read(&snd_ioctl_rwsem); - if (copy_to_user(arg, info, sizeof(snd_ctl_card_info_t))) { + if (copy_to_user(arg, info, sizeof(struct snd_ctl_card_info))) { kfree(info); return -EFAULT; } @@ -541,12 +547,13 @@ static int snd_ctl_card_info(snd_card_t * card, snd_ctl_file_t * ctl, return 0; } -static int snd_ctl_elem_list(snd_card_t *card, snd_ctl_elem_list_t __user *_list) +static int snd_ctl_elem_list(struct snd_card *card, + struct snd_ctl_elem_list __user *_list) { struct list_head *plist; - snd_ctl_elem_list_t list; - snd_kcontrol_t *kctl; - snd_ctl_elem_id_t *dst, *id; + struct snd_ctl_elem_list list; + struct snd_kcontrol *kctl; + struct snd_ctl_elem_id *dst, *id; unsigned int offset, space, first, jidx; if (copy_from_user(&list, _list, sizeof(list))) @@ -559,7 +566,7 @@ static int snd_ctl_elem_list(snd_card_t *card, snd_ctl_elem_list_t __user *_list return -ENOMEM; if (space > 0) { /* allocate temporary buffer for atomic operation */ - dst = vmalloc(space * sizeof(snd_ctl_elem_id_t)); + dst = vmalloc(space * sizeof(struct snd_ctl_elem_id)); if (dst == NULL) return -ENOMEM; down_read(&card->controls_rwsem); @@ -588,7 +595,9 @@ static int snd_ctl_elem_list(snd_card_t *card, snd_ctl_elem_list_t __user *_list offset = 0; } up_read(&card->controls_rwsem); - if (list.used > 0 && copy_to_user(list.pids, dst, list.used * sizeof(snd_ctl_elem_id_t))) { + if (list.used > 0 && + copy_to_user(list.pids, dst, + list.used * sizeof(struct snd_ctl_elem_id))) { vfree(dst); return -EFAULT; } @@ -603,11 +612,12 @@ static int snd_ctl_elem_list(snd_card_t *card, snd_ctl_elem_list_t __user *_list return 0; } -static int snd_ctl_elem_info(snd_ctl_file_t *ctl, snd_ctl_elem_info_t *info) +static int snd_ctl_elem_info(struct snd_ctl_file *ctl, + struct snd_ctl_elem_info *info) { - snd_card_t *card = ctl->card; - snd_kcontrol_t *kctl; - snd_kcontrol_volatile_t *vd; + struct snd_card *card = ctl->card; + struct snd_kcontrol *kctl; + struct snd_kcontrol_volatile *vd; unsigned int index_offset; int result; @@ -640,9 +650,10 @@ static int snd_ctl_elem_info(snd_ctl_file_t *ctl, snd_ctl_elem_info_t *info) return result; } -static int snd_ctl_elem_info_user(snd_ctl_file_t *ctl, snd_ctl_elem_info_t __user *_info) +static int snd_ctl_elem_info_user(struct snd_ctl_file *ctl, + struct snd_ctl_elem_info __user *_info) { - snd_ctl_elem_info_t info; + struct snd_ctl_elem_info info; int result; if (copy_from_user(&info, _info, sizeof(info))) @@ -654,10 +665,10 @@ static int snd_ctl_elem_info_user(snd_ctl_file_t *ctl, snd_ctl_elem_info_t __use return result; } -int snd_ctl_elem_read(snd_card_t *card, snd_ctl_elem_value_t *control) +int snd_ctl_elem_read(struct snd_card *card, struct snd_ctl_elem_value *control) { - snd_kcontrol_t *kctl; - snd_kcontrol_volatile_t *vd; + struct snd_kcontrol *kctl; + struct snd_kcontrol_volatile *vd; unsigned int index_offset; int result, indirect; @@ -684,9 +695,10 @@ int snd_ctl_elem_read(snd_card_t *card, snd_ctl_elem_value_t *control) return result; } -static int snd_ctl_elem_read_user(snd_card_t *card, snd_ctl_elem_value_t __user *_control) +static int snd_ctl_elem_read_user(struct snd_card *card, + struct snd_ctl_elem_value __user *_control) { - snd_ctl_elem_value_t *control; + struct snd_ctl_elem_value *control; int result; control = kmalloc(sizeof(*control), GFP_KERNEL); @@ -704,10 +716,11 @@ static int snd_ctl_elem_read_user(snd_card_t *card, snd_ctl_elem_value_t __user return result; } -int snd_ctl_elem_write(snd_card_t *card, snd_ctl_file_t *file, snd_ctl_elem_value_t *control) +int snd_ctl_elem_write(struct snd_card *card, struct snd_ctl_file *file, + struct snd_ctl_elem_value *control) { - snd_kcontrol_t *kctl; - snd_kcontrol_volatile_t *vd; + struct snd_kcontrol *kctl; + struct snd_kcontrol_volatile *vd; unsigned int index_offset; int result, indirect; @@ -741,9 +754,10 @@ int snd_ctl_elem_write(snd_card_t *card, snd_ctl_file_t *file, snd_ctl_elem_valu return result; } -static int snd_ctl_elem_write_user(snd_ctl_file_t *file, snd_ctl_elem_value_t __user *_control) +static int snd_ctl_elem_write_user(struct snd_ctl_file *file, + struct snd_ctl_elem_value __user *_control) { - snd_ctl_elem_value_t *control; + struct snd_ctl_elem_value *control; int result; control = kmalloc(sizeof(*control), GFP_KERNEL); @@ -761,12 +775,13 @@ static int snd_ctl_elem_write_user(snd_ctl_file_t *file, snd_ctl_elem_value_t __ return result; } -static int snd_ctl_elem_lock(snd_ctl_file_t *file, snd_ctl_elem_id_t __user *_id) +static int snd_ctl_elem_lock(struct snd_ctl_file *file, + struct snd_ctl_elem_id __user *_id) { - snd_card_t *card = file->card; - snd_ctl_elem_id_t id; - snd_kcontrol_t *kctl; - snd_kcontrol_volatile_t *vd; + struct snd_card *card = file->card; + struct snd_ctl_elem_id id; + struct snd_kcontrol *kctl; + struct snd_kcontrol_volatile *vd; int result; if (copy_from_user(&id, _id, sizeof(id))) @@ -789,12 +804,13 @@ static int snd_ctl_elem_lock(snd_ctl_file_t *file, snd_ctl_elem_id_t __user *_id return result; } -static int snd_ctl_elem_unlock(snd_ctl_file_t *file, snd_ctl_elem_id_t __user *_id) +static int snd_ctl_elem_unlock(struct snd_ctl_file *file, + struct snd_ctl_elem_id __user *_id) { - snd_card_t *card = file->card; - snd_ctl_elem_id_t id; - snd_kcontrol_t *kctl; - snd_kcontrol_volatile_t *vd; + struct snd_card *card = file->card; + struct snd_ctl_elem_id id; + struct snd_kcontrol *kctl; + struct snd_kcontrol_volatile *vd; int result; if (copy_from_user(&id, _id, sizeof(id))) @@ -820,14 +836,15 @@ static int snd_ctl_elem_unlock(snd_ctl_file_t *file, snd_ctl_elem_id_t __user *_ } struct user_element { - snd_ctl_elem_info_t info; + struct snd_ctl_elem_info info; void *elem_data; /* element data */ unsigned long elem_data_size; /* size of element data in bytes */ void *priv_data; /* private data (like strings for enumerated type) */ unsigned long priv_data_size; /* size of private data in bytes */ }; -static int snd_ctl_elem_user_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) +static int snd_ctl_elem_user_info(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_info *uinfo) { struct user_element *ue = kcontrol->private_data; @@ -835,7 +852,8 @@ static int snd_ctl_elem_user_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t return 0; } -static int snd_ctl_elem_user_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) +static int snd_ctl_elem_user_get(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) { struct user_element *ue = kcontrol->private_data; @@ -843,7 +861,8 @@ static int snd_ctl_elem_user_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t return 0; } -static int snd_ctl_elem_user_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) +static int snd_ctl_elem_user_put(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) { int change; struct user_element *ue = kcontrol->private_data; @@ -854,15 +873,16 @@ static int snd_ctl_elem_user_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t return change; } -static void snd_ctl_elem_user_free(snd_kcontrol_t * kcontrol) +static void snd_ctl_elem_user_free(struct snd_kcontrol *kcontrol) { kfree(kcontrol->private_data); } -static int snd_ctl_elem_add(snd_ctl_file_t *file, snd_ctl_elem_info_t *info, int replace) +static int snd_ctl_elem_add(struct snd_ctl_file *file, + struct snd_ctl_elem_info *info, int replace) { - snd_card_t *card = file->card; - snd_kcontrol_t kctl, *_kctl; + struct snd_card *card = file->card; + struct snd_kcontrol kctl, *_kctl; unsigned int access; long private_size; struct user_element *ue; @@ -873,7 +893,8 @@ static int snd_ctl_elem_add(snd_ctl_file_t *file, snd_ctl_elem_info_t *info, int if (info->count > 1024) return -EINVAL; access = info->access == 0 ? SNDRV_CTL_ELEM_ACCESS_READWRITE : - (info->access & (SNDRV_CTL_ELEM_ACCESS_READWRITE|SNDRV_CTL_ELEM_ACCESS_INACTIVE)); + (info->access & (SNDRV_CTL_ELEM_ACCESS_READWRITE| + SNDRV_CTL_ELEM_ACCESS_INACTIVE)); info->id.numid = 0; memset(&kctl, 0, sizeof(kctl)); down_write(&card->controls_rwsem); @@ -921,7 +942,7 @@ static int snd_ctl_elem_add(snd_ctl_file_t *file, snd_ctl_elem_info_t *info, int return -EINVAL; break; case SNDRV_CTL_ELEM_TYPE_IEC958: - private_size = sizeof(struct sndrv_aes_iec958); + private_size = sizeof(struct snd_aes_iec958); if (info->count != 1) return -EINVAL; break; @@ -957,24 +978,26 @@ static int snd_ctl_elem_add(snd_ctl_file_t *file, snd_ctl_elem_info_t *info, int return 0; } -static int snd_ctl_elem_add_user(snd_ctl_file_t *file, snd_ctl_elem_info_t __user *_info, int replace) +static int snd_ctl_elem_add_user(struct snd_ctl_file *file, + struct snd_ctl_elem_info __user *_info, int replace) { - snd_ctl_elem_info_t info; + struct snd_ctl_elem_info info; if (copy_from_user(&info, _info, sizeof(info))) return -EFAULT; return snd_ctl_elem_add(file, &info, replace); } -static int snd_ctl_elem_remove(snd_ctl_file_t *file, snd_ctl_elem_id_t __user *_id) +static int snd_ctl_elem_remove(struct snd_ctl_file *file, + struct snd_ctl_elem_id __user *_id) { - snd_ctl_elem_id_t id; + struct snd_ctl_elem_id id; int err; if (copy_from_user(&id, _id, sizeof(id))) return -EFAULT; err = snd_ctl_remove_unlocked_id(file, &id); if (! err) { - snd_card_t *card = file->card; + struct snd_card *card = file->card; down_write(&card->controls_rwsem); card->user_ctl_count--; up_write(&card->controls_rwsem); @@ -982,7 +1005,7 @@ static int snd_ctl_elem_remove(snd_ctl_file_t *file, snd_ctl_elem_id_t __user *_ return err; } -static int snd_ctl_subscribe_events(snd_ctl_file_t *file, int __user *ptr) +static int snd_ctl_subscribe_events(struct snd_ctl_file *file, int __user *ptr) { int subscribe; if (get_user(subscribe, ptr)) @@ -1003,42 +1026,12 @@ static int snd_ctl_subscribe_events(snd_ctl_file_t *file, int __user *ptr) return 0; } -#ifdef CONFIG_PM -/* - * change the power state - */ -static int snd_ctl_set_power_state(snd_card_t *card, unsigned int power_state) -{ - switch (power_state) { - case SNDRV_CTL_POWER_D0: - if (card->power_state != power_state) { - card->pm_resume(card); - snd_power_change_state(card, power_state); - } - break; - case SNDRV_CTL_POWER_D3hot: - if (card->power_state != power_state) { - card->pm_suspend(card, PMSG_SUSPEND); - snd_power_change_state(card, power_state); - } - break; - case SNDRV_CTL_POWER_D1: - case SNDRV_CTL_POWER_D2: - case SNDRV_CTL_POWER_D3cold: - /* not supported yet */ - default: - return -EINVAL; - } - return 0; -} -#endif - static long snd_ctl_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { - snd_ctl_file_t *ctl; - snd_card_t *card; + struct snd_ctl_file *ctl; + struct snd_card *card; struct list_head *list; - snd_kctl_ioctl_t *p; + struct snd_kctl_ioctl *p; void __user *argp = (void __user *)arg; int __user *ip = argp; int err; @@ -1072,19 +1065,7 @@ static long snd_ctl_ioctl(struct file *file, unsigned int cmd, unsigned long arg case SNDRV_CTL_IOCTL_SUBSCRIBE_EVENTS: return snd_ctl_subscribe_events(ctl, ip); case SNDRV_CTL_IOCTL_POWER: - if (get_user(err, ip)) - return -EFAULT; - if (!capable(CAP_SYS_ADMIN)) - return -EPERM; -#ifdef CONFIG_PM - if (card->pm_suspend && card->pm_resume) { - snd_power_lock(card); - err = snd_ctl_set_power_state(card, err); - snd_power_unlock(card); - } else -#endif - err = -ENOPROTOOPT; - return err; + return -ENOPROTOOPT; case SNDRV_CTL_IOCTL_POWER_STATE: #ifdef CONFIG_PM return put_user(card->power_state, ip) ? -EFAULT : 0; @@ -1094,7 +1075,7 @@ static long snd_ctl_ioctl(struct file *file, unsigned int cmd, unsigned long arg } down_read(&snd_ioctl_rwsem); list_for_each(list, &snd_control_ioctls) { - p = list_entry(list, snd_kctl_ioctl_t, list); + p = list_entry(list, struct snd_kctl_ioctl, list); err = p->fioctl(card, ctl, cmd, arg); if (err != -ENOIOCTLCMD) { up_read(&snd_ioctl_rwsem); @@ -1106,9 +1087,10 @@ static long snd_ctl_ioctl(struct file *file, unsigned int cmd, unsigned long arg return -ENOTTY; } -static ssize_t snd_ctl_read(struct file *file, char __user *buffer, size_t count, loff_t * offset) +static ssize_t snd_ctl_read(struct file *file, char __user *buffer, + size_t count, loff_t * offset) { - snd_ctl_file_t *ctl; + struct snd_ctl_file *ctl; int err = 0; ssize_t result = 0; @@ -1116,12 +1098,12 @@ static ssize_t snd_ctl_read(struct file *file, char __user *buffer, size_t count snd_assert(ctl != NULL && ctl->card != NULL, return -ENXIO); if (!ctl->subscribed) return -EBADFD; - if (count < sizeof(snd_ctl_event_t)) + if (count < sizeof(struct snd_ctl_event)) return -EINVAL; spin_lock_irq(&ctl->read_lock); - while (count >= sizeof(snd_ctl_event_t)) { - snd_ctl_event_t ev; - snd_kctl_event_t *kev; + while (count >= sizeof(struct snd_ctl_event)) { + struct snd_ctl_event ev; + struct snd_kctl_event *kev; while (list_empty(&ctl->events)) { wait_queue_t wait; if ((file->f_flags & O_NONBLOCK) != 0 || result > 0) { @@ -1145,14 +1127,14 @@ static ssize_t snd_ctl_read(struct file *file, char __user *buffer, size_t count list_del(&kev->list); spin_unlock_irq(&ctl->read_lock); kfree(kev); - if (copy_to_user(buffer, &ev, sizeof(snd_ctl_event_t))) { + if (copy_to_user(buffer, &ev, sizeof(struct snd_ctl_event))) { err = -EFAULT; goto __end; } spin_lock_irq(&ctl->read_lock); - buffer += sizeof(snd_ctl_event_t); - count -= sizeof(snd_ctl_event_t); - result += sizeof(snd_ctl_event_t); + buffer += sizeof(struct snd_ctl_event); + count -= sizeof(struct snd_ctl_event); + result += sizeof(struct snd_ctl_event); } __end_lock: spin_unlock_irq(&ctl->read_lock); @@ -1163,7 +1145,7 @@ static ssize_t snd_ctl_read(struct file *file, char __user *buffer, size_t count static unsigned int snd_ctl_poll(struct file *file, poll_table * wait) { unsigned int mask; - snd_ctl_file_t *ctl; + struct snd_ctl_file *ctl; ctl = file->private_data; if (!ctl->subscribed) @@ -1183,9 +1165,9 @@ static unsigned int snd_ctl_poll(struct file *file, poll_table * wait) */ static int _snd_ctl_register_ioctl(snd_kctl_ioctl_func_t fcn, struct list_head *lists) { - snd_kctl_ioctl_t *pn; + struct snd_kctl_ioctl *pn; - pn = kzalloc(sizeof(snd_kctl_ioctl_t), GFP_KERNEL); + pn = kzalloc(sizeof(struct snd_kctl_ioctl), GFP_KERNEL); if (pn == NULL) return -ENOMEM; pn->fioctl = fcn; @@ -1210,15 +1192,16 @@ int snd_ctl_register_ioctl_compat(snd_kctl_ioctl_func_t fcn) /* * de-register the device-specific control-ioctls. */ -static int _snd_ctl_unregister_ioctl(snd_kctl_ioctl_func_t fcn, struct list_head *lists) +static int _snd_ctl_unregister_ioctl(snd_kctl_ioctl_func_t fcn, + struct list_head *lists) { struct list_head *list; - snd_kctl_ioctl_t *p; + struct snd_kctl_ioctl *p; snd_assert(fcn != NULL, return -EINVAL); down_write(&snd_ioctl_rwsem); list_for_each(list, lists) { - p = list_entry(list, snd_kctl_ioctl_t, list); + p = list_entry(list, struct snd_kctl_ioctl, list); if (p->fioctl == fcn) { list_del(&p->list); up_write(&snd_ioctl_rwsem); @@ -1246,7 +1229,7 @@ int snd_ctl_unregister_ioctl_compat(snd_kctl_ioctl_func_t fcn) static int snd_ctl_fasync(int fd, struct file * file, int on) { - snd_ctl_file_t *ctl; + struct snd_ctl_file *ctl; int err; ctl = file->private_data; err = fasync_helper(fd, file, on, &ctl->fasync); @@ -1280,18 +1263,12 @@ static struct file_operations snd_ctl_f_ops = .fasync = snd_ctl_fasync, }; -static snd_minor_t snd_ctl_reg = -{ - .comment = "ctl", - .f_ops = &snd_ctl_f_ops, -}; - /* * registration of the control device */ -static int snd_ctl_dev_register(snd_device_t *device) +static int snd_ctl_dev_register(struct snd_device *device) { - snd_card_t *card = device->device_data; + struct snd_card *card = device->device_data; int err, cardnum; char name[16]; @@ -1299,8 +1276,8 @@ static int snd_ctl_dev_register(snd_device_t *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, 0, &snd_ctl_reg, name)) < 0) + if ((err = snd_register_device(SNDRV_DEVICE_TYPE_CONTROL, card, -1, + &snd_ctl_f_ops, card, name)) < 0) return err; return 0; } @@ -1308,11 +1285,11 @@ static int snd_ctl_dev_register(snd_device_t *device) /* * disconnection of the control device */ -static int snd_ctl_dev_disconnect(snd_device_t *device) +static int snd_ctl_dev_disconnect(struct snd_device *device) { - snd_card_t *card = device->device_data; + struct snd_card *card = device->device_data; struct list_head *flist; - snd_ctl_file_t *ctl; + struct snd_ctl_file *ctl; down_read(&card->controls_rwsem); list_for_each(flist, &card->ctl_files) { @@ -1327,10 +1304,10 @@ static int snd_ctl_dev_disconnect(snd_device_t *device) /* * free all controls */ -static int snd_ctl_dev_free(snd_device_t *device) +static int snd_ctl_dev_free(struct snd_device *device) { - snd_card_t *card = device->device_data; - snd_kcontrol_t *control; + struct snd_card *card = device->device_data; + struct snd_kcontrol *control; down_write(&card->controls_rwsem); while (!list_empty(&card->controls)) { @@ -1344,15 +1321,16 @@ static int snd_ctl_dev_free(snd_device_t *device) /* * de-registration of the control device */ -static int snd_ctl_dev_unregister(snd_device_t *device) +static int snd_ctl_dev_unregister(struct snd_device *device) { - snd_card_t *card = device->device_data; + struct snd_card *card = device->device_data; int err, cardnum; 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); } @@ -1361,9 +1339,9 @@ static int snd_ctl_dev_unregister(snd_device_t *device) * create control core: * called from init.c */ -int snd_ctl_create(snd_card_t *card) +int snd_ctl_create(struct snd_card *card) { - static snd_device_ops_t ops = { + static struct snd_device_ops ops = { .dev_free = snd_ctl_dev_free, .dev_register = snd_ctl_dev_register, .dev_disconnect = snd_ctl_dev_disconnect, diff --git a/sound/core/control_compat.c b/sound/core/control_compat.c index 207c7de5129..418c6d4e5da 100644 --- a/sound/core/control_compat.c +++ b/sound/core/control_compat.c @@ -22,7 +22,7 @@ #include <linux/compat.h> -struct sndrv_ctl_elem_list32 { +struct snd_ctl_elem_list32 { u32 offset; u32 space; u32 used; @@ -31,9 +31,10 @@ struct sndrv_ctl_elem_list32 { unsigned char reserved[50]; } /* don't set packed attribute here */; -static int snd_ctl_elem_list_compat(snd_card_t *card, struct sndrv_ctl_elem_list32 __user *data32) +static int snd_ctl_elem_list_compat(struct snd_card *card, + struct snd_ctl_elem_list32 __user *data32) { - struct sndrv_ctl_elem_list __user *data; + struct snd_ctl_elem_list __user *data; compat_caddr_t ptr; int err; @@ -60,8 +61,8 @@ static int snd_ctl_elem_list_compat(snd_card_t *card, struct sndrv_ctl_elem_list * it uses union, so the things are not easy.. */ -struct sndrv_ctl_elem_info32 { - struct sndrv_ctl_elem_id id; // the size of struct is same +struct snd_ctl_elem_info32 { + struct snd_ctl_elem_id id; // the size of struct is same s32 type; u32 access; u32 count; @@ -87,9 +88,10 @@ struct sndrv_ctl_elem_info32 { unsigned char reserved[64]; } __attribute__((packed)); -static int snd_ctl_elem_info_compat(snd_ctl_file_t *ctl, struct sndrv_ctl_elem_info32 __user *data32) +static int snd_ctl_elem_info_compat(struct snd_ctl_file *ctl, + struct snd_ctl_elem_info32 __user *data32) { - struct sndrv_ctl_elem_info *data; + struct snd_ctl_elem_info *data; int err; data = kzalloc(sizeof(*data), GFP_KERNEL); @@ -146,8 +148,8 @@ static int snd_ctl_elem_info_compat(snd_ctl_file_t *ctl, struct sndrv_ctl_elem_i } /* read / write */ -struct sndrv_ctl_elem_value32 { - struct sndrv_ctl_elem_id id; +struct snd_ctl_elem_value32 { + struct snd_ctl_elem_id id; unsigned int indirect; /* bit-field causes misalignment */ union { s32 integer[128]; @@ -161,10 +163,11 @@ struct sndrv_ctl_elem_value32 { /* get the value type and count of the control */ -static int get_ctl_type(snd_card_t *card, snd_ctl_elem_id_t *id, int *countp) +static int get_ctl_type(struct snd_card *card, struct snd_ctl_elem_id *id, + int *countp) { - snd_kcontrol_t *kctl; - snd_ctl_elem_info_t info; + struct snd_kcontrol *kctl; + struct snd_ctl_elem_info info; int err; down_read(&card->controls_rwsem); @@ -193,15 +196,15 @@ static int get_elem_size(int type, int count) case SNDRV_CTL_ELEM_TYPE_BYTES: return 512; case SNDRV_CTL_ELEM_TYPE_IEC958: - return sizeof(struct sndrv_aes_iec958); + return sizeof(struct snd_aes_iec958); default: return -1; } } -static int copy_ctl_value_from_user(snd_card_t *card, - struct sndrv_ctl_elem_value *data, - struct sndrv_ctl_elem_value32 __user *data32, +static int copy_ctl_value_from_user(struct snd_card *card, + struct snd_ctl_elem_value *data, + struct snd_ctl_elem_value32 __user *data32, int *typep, int *countp) { int i, type, count, size; @@ -242,8 +245,8 @@ static int copy_ctl_value_from_user(snd_card_t *card, } /* restore the value to 32bit */ -static int copy_ctl_value_to_user(struct sndrv_ctl_elem_value32 __user *data32, - struct sndrv_ctl_elem_value *data, +static int copy_ctl_value_to_user(struct snd_ctl_elem_value32 __user *data32, + struct snd_ctl_elem_value *data, int type, int count) { int i, size; @@ -265,10 +268,10 @@ static int copy_ctl_value_to_user(struct sndrv_ctl_elem_value32 __user *data32, return 0; } -static int snd_ctl_elem_read_user_compat(snd_card_t *card, - struct sndrv_ctl_elem_value32 __user *data32) +static int snd_ctl_elem_read_user_compat(struct snd_card *card, + struct snd_ctl_elem_value32 __user *data32) { - struct sndrv_ctl_elem_value *data; + struct snd_ctl_elem_value *data; int err, type, count; data = kzalloc(sizeof(*data), GFP_KERNEL); @@ -285,10 +288,10 @@ static int snd_ctl_elem_read_user_compat(snd_card_t *card, return err; } -static int snd_ctl_elem_write_user_compat(snd_ctl_file_t *file, - struct sndrv_ctl_elem_value32 __user *data32) +static int snd_ctl_elem_write_user_compat(struct snd_ctl_file *file, + struct snd_ctl_elem_value32 __user *data32) { - struct sndrv_ctl_elem_value *data; + struct snd_ctl_elem_value *data; int err, type, count; data = kzalloc(sizeof(*data), GFP_KERNEL); @@ -306,11 +309,11 @@ static int snd_ctl_elem_write_user_compat(snd_ctl_file_t *file, } /* add or replace a user control */ -static int snd_ctl_elem_add_compat(snd_ctl_file_t *file, - struct sndrv_ctl_elem_info32 __user *data32, +static int snd_ctl_elem_add_compat(struct snd_ctl_file *file, + struct snd_ctl_elem_info32 __user *data32, int replace) { - struct sndrv_ctl_elem_info *data; + struct snd_ctl_elem_info *data; int err; data = kzalloc(sizeof(*data), GFP_KERNEL); @@ -355,17 +358,17 @@ static int snd_ctl_elem_add_compat(snd_ctl_file_t *file, } enum { - SNDRV_CTL_IOCTL_ELEM_LIST32 = _IOWR('U', 0x10, struct sndrv_ctl_elem_list32), - SNDRV_CTL_IOCTL_ELEM_INFO32 = _IOWR('U', 0x11, struct sndrv_ctl_elem_info32), - SNDRV_CTL_IOCTL_ELEM_READ32 = _IOWR('U', 0x12, struct sndrv_ctl_elem_value32), - SNDRV_CTL_IOCTL_ELEM_WRITE32 = _IOWR('U', 0x13, struct sndrv_ctl_elem_value32), - SNDRV_CTL_IOCTL_ELEM_ADD32 = _IOWR('U', 0x17, struct sndrv_ctl_elem_info32), - SNDRV_CTL_IOCTL_ELEM_REPLACE32 = _IOWR('U', 0x18, struct sndrv_ctl_elem_info32), + SNDRV_CTL_IOCTL_ELEM_LIST32 = _IOWR('U', 0x10, struct snd_ctl_elem_list32), + SNDRV_CTL_IOCTL_ELEM_INFO32 = _IOWR('U', 0x11, struct snd_ctl_elem_info32), + SNDRV_CTL_IOCTL_ELEM_READ32 = _IOWR('U', 0x12, struct snd_ctl_elem_value32), + SNDRV_CTL_IOCTL_ELEM_WRITE32 = _IOWR('U', 0x13, struct snd_ctl_elem_value32), + SNDRV_CTL_IOCTL_ELEM_ADD32 = _IOWR('U', 0x17, struct snd_ctl_elem_info32), + SNDRV_CTL_IOCTL_ELEM_REPLACE32 = _IOWR('U', 0x18, struct snd_ctl_elem_info32), }; static inline long snd_ctl_ioctl_compat(struct file *file, unsigned int cmd, unsigned long arg) { - snd_ctl_file_t *ctl; + struct snd_ctl_file *ctl; struct list_head *list; void __user *argp = compat_ptr(arg); int err; @@ -398,7 +401,7 @@ static inline long snd_ctl_ioctl_compat(struct file *file, unsigned int cmd, uns down_read(&snd_ioctl_rwsem); list_for_each(list, &snd_control_compat_ioctls) { - snd_kctl_ioctl_t *p = list_entry(list, snd_kctl_ioctl_t, list); + struct snd_kctl_ioctl *p = list_entry(list, struct snd_kctl_ioctl, list); if (p->fioctl) { err = p->fioctl(ctl->card, ctl, cmd, arg); if (err != -ENOIOCTLCMD) { diff --git a/sound/core/device.c b/sound/core/device.c index 1f509f56e60..b1cf6ec5678 100644 --- a/sound/core/device.c +++ b/sound/core/device.c @@ -41,17 +41,19 @@ * * Returns zero if successful, or a negative error code on failure. */ -int snd_device_new(snd_card_t *card, snd_device_type_t type, - void *device_data, snd_device_ops_t *ops) +int snd_device_new(struct snd_card *card, snd_device_type_t type, + void *device_data, struct snd_device_ops *ops) { - snd_device_t *dev; + struct snd_device *dev; snd_assert(card != NULL, return -ENXIO); snd_assert(device_data != NULL, return -ENXIO); snd_assert(ops != NULL, return -ENXIO); dev = kzalloc(sizeof(*dev), GFP_KERNEL); - if (dev == NULL) + if (dev == NULL) { + snd_printk(KERN_ERR "Cannot allocate device\n"); return -ENOMEM; + } dev->card = card; dev->type = type; dev->state = SNDRV_DEV_BUILD; @@ -73,10 +75,10 @@ int snd_device_new(snd_card_t *card, snd_device_type_t type, * Returns zero if successful, or a negative error code on failure or if the * device not found. */ -int snd_device_free(snd_card_t *card, void *device_data) +int snd_device_free(struct snd_card *card, void *device_data) { struct list_head *list; - snd_device_t *dev; + struct snd_device *dev; snd_assert(card != NULL, return -ENXIO); snd_assert(device_data != NULL, return -ENXIO); @@ -86,7 +88,8 @@ int snd_device_free(snd_card_t *card, void *device_data) continue; /* unlink */ list_del(&dev->list); - if ((dev->state == SNDRV_DEV_REGISTERED || dev->state == SNDRV_DEV_DISCONNECTED) && + if ((dev->state == SNDRV_DEV_REGISTERED || + dev->state == SNDRV_DEV_DISCONNECTED) && dev->ops->dev_unregister) { if (dev->ops->dev_unregister(dev)) snd_printk(KERN_ERR "device unregister failure\n"); @@ -99,7 +102,8 @@ int snd_device_free(snd_card_t *card, void *device_data) kfree(dev); return 0; } - snd_printd("device free %p (from %p), not found\n", device_data, __builtin_return_address(0)); + snd_printd("device free %p (from %p), not found\n", device_data, + __builtin_return_address(0)); return -ENXIO; } @@ -116,10 +120,10 @@ int snd_device_free(snd_card_t *card, void *device_data) * Returns zero if successful, or a negative error code on failure or if the * device not found. */ -int snd_device_disconnect(snd_card_t *card, void *device_data) +int snd_device_disconnect(struct snd_card *card, void *device_data) { struct list_head *list; - snd_device_t *dev; + struct snd_device *dev; snd_assert(card != NULL, return -ENXIO); snd_assert(device_data != NULL, return -ENXIO); @@ -127,14 +131,16 @@ int snd_device_disconnect(snd_card_t *card, void *device_data) dev = snd_device(list); if (dev->device_data != device_data) continue; - if (dev->state == SNDRV_DEV_REGISTERED && dev->ops->dev_disconnect) { + if (dev->state == SNDRV_DEV_REGISTERED && + dev->ops->dev_disconnect) { if (dev->ops->dev_disconnect(dev)) snd_printk(KERN_ERR "device disconnect failure\n"); dev->state = SNDRV_DEV_DISCONNECTED; } return 0; } - snd_printd("device disconnect %p (from %p), not found\n", device_data, __builtin_return_address(0)); + snd_printd("device disconnect %p (from %p), not found\n", device_data, + __builtin_return_address(0)); return -ENXIO; } @@ -151,10 +157,10 @@ int snd_device_disconnect(snd_card_t *card, void *device_data) * Returns zero if successful, or a negative error code on failure or if the * device not found. */ -int snd_device_register(snd_card_t *card, void *device_data) +int snd_device_register(struct snd_card *card, void *device_data) { struct list_head *list; - snd_device_t *dev; + struct snd_device *dev; int err; snd_assert(card != NULL, return -ENXIO); @@ -169,6 +175,7 @@ int snd_device_register(snd_card_t *card, void *device_data) dev->state = SNDRV_DEV_REGISTERED; return 0; } + snd_printd("snd_device_register busy\n"); return -EBUSY; } snd_BUG(); @@ -179,10 +186,10 @@ int snd_device_register(snd_card_t *card, void *device_data) * register all the devices on the card. * called from init.c */ -int snd_device_register_all(snd_card_t *card) +int snd_device_register_all(struct snd_card *card) { struct list_head *list; - snd_device_t *dev; + struct snd_device *dev; int err; snd_assert(card != NULL, return -ENXIO); @@ -201,9 +208,9 @@ int snd_device_register_all(snd_card_t *card) * disconnect all the devices on the card. * called from init.c */ -int snd_device_disconnect_all(snd_card_t *card) +int snd_device_disconnect_all(struct snd_card *card) { - snd_device_t *dev; + struct snd_device *dev; struct list_head *list; int err = 0; @@ -220,9 +227,9 @@ int snd_device_disconnect_all(snd_card_t *card) * release all the devices on the card. * called from init.c */ -int snd_device_free_all(snd_card_t *card, snd_device_cmd_t cmd) +int snd_device_free_all(struct snd_card *card, snd_device_cmd_t cmd) { - snd_device_t *dev; + struct snd_device *dev; struct list_head *list; int err; unsigned int range_low, range_high; diff --git a/sound/core/hwdep.c b/sound/core/hwdep.c index e91cee35a4b..618c43be0bc 100644 --- a/sound/core/hwdep.c +++ b/sound/core/hwdep.c @@ -35,38 +35,49 @@ MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>"); MODULE_DESCRIPTION("Hardware dependent layer"); MODULE_LICENSE("GPL"); -static snd_hwdep_t *snd_hwdep_devices[SNDRV_CARDS * SNDRV_MINOR_HWDEPS]; - +static LIST_HEAD(snd_hwdep_devices); static DECLARE_MUTEX(register_mutex); -static int snd_hwdep_free(snd_hwdep_t *hwdep); -static int snd_hwdep_dev_free(snd_device_t *device); -static int snd_hwdep_dev_register(snd_device_t *device); -static int snd_hwdep_dev_unregister(snd_device_t *device); +static int snd_hwdep_free(struct snd_hwdep *hwdep); +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) { - snd_hwdep_t *hw = file->private_data; + struct snd_hwdep *hw = file->private_data; if (hw->ops.llseek) return hw->ops.llseek(hw, file, offset, orig); return -ENXIO; } -static ssize_t snd_hwdep_read(struct file * file, char __user *buf, size_t count, loff_t *offset) +static ssize_t snd_hwdep_read(struct file * file, char __user *buf, + size_t count, loff_t *offset) { - snd_hwdep_t *hw = file->private_data; + struct snd_hwdep *hw = file->private_data; if (hw->ops.read) return hw->ops.read(hw, buf, count, offset); return -ENXIO; } -static ssize_t snd_hwdep_write(struct file * file, const char __user *buf, size_t count, loff_t *offset) +static ssize_t snd_hwdep_write(struct file * file, const char __user *buf, + size_t count, loff_t *offset) { - snd_hwdep_t *hw = file->private_data; + struct snd_hwdep *hw = file->private_data; if (hw->ops.write) return hw->ops.write(hw, buf, count, offset); return -ENXIO; @@ -75,34 +86,25 @@ static ssize_t snd_hwdep_write(struct file * file, const char __user *buf, size_ static int snd_hwdep_open(struct inode *inode, struct file * file) { int major = imajor(inode); - int cardnum; - int device; - snd_hwdep_t *hw; + 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; @@ -154,7 +156,7 @@ static int snd_hwdep_open(struct inode *inode, struct file * file) static int snd_hwdep_release(struct inode *inode, struct file * file) { int err = -ENXIO; - snd_hwdep_t *hw = file->private_data; + struct snd_hwdep *hw = file->private_data; down(&hw->open_mutex); if (hw->ops.release) { err = hw->ops.release(hw, file); @@ -170,15 +172,16 @@ static int snd_hwdep_release(struct inode *inode, struct file * file) static unsigned int snd_hwdep_poll(struct file * file, poll_table * wait) { - snd_hwdep_t *hw = file->private_data; + struct snd_hwdep *hw = file->private_data; if (hw->ops.poll) return hw->ops.poll(hw, file, wait); return 0; } -static int snd_hwdep_info(snd_hwdep_t *hw, snd_hwdep_info_t __user *_info) +static int snd_hwdep_info(struct snd_hwdep *hw, + struct snd_hwdep_info __user *_info) { - snd_hwdep_info_t info; + struct snd_hwdep_info info; memset(&info, 0, sizeof(info)); info.card = hw->card->number; @@ -190,9 +193,10 @@ static int snd_hwdep_info(snd_hwdep_t *hw, snd_hwdep_info_t __user *_info) return 0; } -static int snd_hwdep_dsp_status(snd_hwdep_t *hw, snd_hwdep_dsp_status_t __user *_info) +static int snd_hwdep_dsp_status(struct snd_hwdep *hw, + struct snd_hwdep_dsp_status __user *_info) { - snd_hwdep_dsp_status_t info; + struct snd_hwdep_dsp_status info; int err; if (! hw->ops.dsp_status) @@ -206,9 +210,10 @@ static int snd_hwdep_dsp_status(snd_hwdep_t *hw, snd_hwdep_dsp_status_t __user * return 0; } -static int snd_hwdep_dsp_load(snd_hwdep_t *hw, snd_hwdep_dsp_image_t __user *_info) +static int snd_hwdep_dsp_load(struct snd_hwdep *hw, + struct snd_hwdep_dsp_image __user *_info) { - snd_hwdep_dsp_image_t info; + struct snd_hwdep_dsp_image info; int err; if (! hw->ops.dsp_load) @@ -228,9 +233,10 @@ static int snd_hwdep_dsp_load(snd_hwdep_t *hw, snd_hwdep_dsp_image_t __user *_in return 0; } -static long snd_hwdep_ioctl(struct file * file, unsigned int cmd, unsigned long arg) +static long snd_hwdep_ioctl(struct file * file, unsigned int cmd, + unsigned long arg) { - snd_hwdep_t *hw = file->private_data; + struct snd_hwdep *hw = file->private_data; void __user *argp = (void __user *)arg; switch (cmd) { case SNDRV_HWDEP_IOCTL_PVERSION: @@ -249,18 +255,16 @@ static long snd_hwdep_ioctl(struct file * file, unsigned int cmd, unsigned long static int snd_hwdep_mmap(struct file * file, struct vm_area_struct * vma) { - snd_hwdep_t *hw = file->private_data; + struct snd_hwdep *hw = file->private_data; if (hw->ops.mmap) return hw->ops.mmap(hw, file, vma); return -ENXIO; } -static int snd_hwdep_control_ioctl(snd_card_t * card, snd_ctl_file_t * control, +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: { @@ -268,32 +272,36 @@ static int snd_hwdep_control_ioctl(snd_card_t * card, snd_ctl_file_t * control, 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; } case SNDRV_CTL_IOCTL_HWDEP_INFO: { - snd_hwdep_info_t __user *info = (snd_hwdep_info_t __user *)arg; - int device; - snd_hwdep_t *hwdep; + struct snd_hwdep_info __user *info = (struct snd_hwdep_info __user *)arg; + 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; @@ -323,12 +331,6 @@ static struct file_operations snd_hwdep_f_ops = .mmap = snd_hwdep_mmap, }; -static snd_minor_t snd_hwdep_reg = -{ - .comment = "hardware dependent", - .f_ops = &snd_hwdep_f_ops, -}; - /** * snd_hwdep_new - create a new hwdep instance * @card: the card instance @@ -342,11 +344,12 @@ static snd_minor_t snd_hwdep_reg = * * Returns zero if successful, or a negative error code on failure. */ -int snd_hwdep_new(snd_card_t * card, char *id, int device, snd_hwdep_t ** rhwdep) +int snd_hwdep_new(struct snd_card *card, char *id, int device, + struct snd_hwdep **rhwdep) { - snd_hwdep_t *hwdep; + struct snd_hwdep *hwdep; int err; - static snd_device_ops_t ops = { + static struct snd_device_ops ops = { .dev_free = snd_hwdep_dev_free, .dev_register = snd_hwdep_dev_register, .dev_unregister = snd_hwdep_dev_unregister @@ -356,13 +359,14 @@ int snd_hwdep_new(snd_card_t * card, char *id, int device, snd_hwdep_t ** rhwdep *rhwdep = NULL; snd_assert(card != NULL, return -ENXIO); hwdep = kzalloc(sizeof(*hwdep), GFP_KERNEL); - if (hwdep == NULL) + if (hwdep == NULL) { + snd_printk(KERN_ERR "hwdep: cannot allocate\n"); return -ENOMEM; + } hwdep->card = card; hwdep->device = device; - if (id) { + if (id) strlcpy(hwdep->id, id, sizeof(hwdep->id)); - } #ifdef CONFIG_SND_OSSEMUL hwdep->oss_type = -1; #endif @@ -376,7 +380,7 @@ int snd_hwdep_new(snd_card_t * card, char *id, int device, snd_hwdep_t ** rhwdep return 0; } -static int snd_hwdep_free(snd_hwdep_t *hwdep) +static int snd_hwdep_free(struct snd_hwdep *hwdep) { snd_assert(hwdep != NULL, return -ENXIO); if (hwdep->private_free) @@ -385,32 +389,31 @@ static int snd_hwdep_free(snd_hwdep_t *hwdep) return 0; } -static int snd_hwdep_dev_free(snd_device_t *device) +static int snd_hwdep_dev_free(struct snd_device *device) { - snd_hwdep_t *hwdep = device->device_data; + struct snd_hwdep *hwdep = device->device_data; return snd_hwdep_free(hwdep); } -static int snd_hwdep_dev_register(snd_device_t *device) +static int snd_hwdep_dev_register(struct snd_device *device) { - snd_hwdep_t *hwdep = device->device_data; - int idx, err; + struct snd_hwdep *hwdep = device->device_data; + 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_reg, 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; } @@ -422,7 +425,8 @@ static int snd_hwdep_dev_register(snd_device_t *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, + hwdep->oss_dev) < 0) { snd_printk(KERN_ERR "unable to register OSS compatibility device %i:%i\n", hwdep->card->number, hwdep->device); } else @@ -434,15 +438,13 @@ static int snd_hwdep_dev_register(snd_device_t *device) return 0; } -static int snd_hwdep_dev_unregister(snd_device_t *device) +static int snd_hwdep_dev_unregister(struct snd_device *device) { - snd_hwdep_t *hwdep = device->device_data; - int idx; + struct snd_hwdep *hwdep = device->device_data; 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; } @@ -451,47 +453,39 @@ static int snd_hwdep_dev_unregister(snd_device_t *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); } +#ifdef CONFIG_PROC_FS /* * Info interface */ -static void snd_hwdep_proc_read(snd_info_entry_t *entry, - snd_info_buffer_t * buffer) +static void snd_hwdep_proc_read(struct snd_info_entry *entry, + struct snd_info_buffer *buffer) { - int idx; - snd_hwdep_t *hwdep; + 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); } -/* - * ENTRY functions - */ +static struct snd_info_entry *snd_hwdep_proc_entry; -static snd_info_entry_t *snd_hwdep_proc_entry = NULL; - -static int __init alsa_hwdep_init(void) +static void __init snd_hwdep_proc_init(void) { - snd_info_entry_t *entry; + 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); @@ -499,6 +493,25 @@ static int __init alsa_hwdep_init(void) } } snd_hwdep_proc_entry = entry; +} + +static void __exit snd_hwdep_proc_done(void) +{ + snd_info_unregister(snd_hwdep_proc_entry); +} +#else /* !CONFIG_PROC_FS */ +#define snd_hwdep_proc_init() +#define snd_hwdep_proc_done() +#endif /* CONFIG_PROC_FS */ + + +/* + * ENTRY functions + */ + +static int __init alsa_hwdep_init(void) +{ + snd_hwdep_proc_init(); snd_ctl_register_ioctl(snd_hwdep_control_ioctl); snd_ctl_register_ioctl_compat(snd_hwdep_control_ioctl); return 0; @@ -508,10 +521,7 @@ static void __exit alsa_hwdep_exit(void) { snd_ctl_unregister_ioctl(snd_hwdep_control_ioctl); snd_ctl_unregister_ioctl_compat(snd_hwdep_control_ioctl); - if (snd_hwdep_proc_entry) { - snd_info_unregister(snd_hwdep_proc_entry); - snd_hwdep_proc_entry = NULL; - } + snd_hwdep_proc_done(); } module_init(alsa_hwdep_init) diff --git a/sound/core/hwdep_compat.c b/sound/core/hwdep_compat.c index 6866f423d4b..938f7758096 100644 --- a/sound/core/hwdep_compat.c +++ b/sound/core/hwdep_compat.c @@ -22,7 +22,7 @@ #include <linux/compat.h> -struct sndrv_hwdep_dsp_image32 { +struct snd_hwdep_dsp_image32 { u32 index; unsigned char name[64]; u32 image; /* pointer */ @@ -30,10 +30,10 @@ struct sndrv_hwdep_dsp_image32 { u32 driver_data; } /* don't set packed attribute here */; -static int snd_hwdep_dsp_load_compat(snd_hwdep_t *hw, - struct sndrv_hwdep_dsp_image32 __user *src) +static int snd_hwdep_dsp_load_compat(struct snd_hwdep *hw, + struct snd_hwdep_dsp_image32 __user *src) { - struct sndrv_hwdep_dsp_image *dst; + struct snd_hwdep_dsp_image *dst; compat_caddr_t ptr; u32 val; @@ -56,12 +56,13 @@ static int snd_hwdep_dsp_load_compat(snd_hwdep_t *hw, } enum { - SNDRV_HWDEP_IOCTL_DSP_LOAD32 = _IOW('H', 0x03, struct sndrv_hwdep_dsp_image32) + SNDRV_HWDEP_IOCTL_DSP_LOAD32 = _IOW('H', 0x03, struct snd_hwdep_dsp_image32) }; -static long snd_hwdep_ioctl_compat(struct file * file, unsigned int cmd, unsigned long arg) +static long snd_hwdep_ioctl_compat(struct file * file, unsigned int cmd, + unsigned long arg) { - snd_hwdep_t *hw = file->private_data; + struct snd_hwdep *hw = file->private_data; void __user *argp = compat_ptr(arg); switch (cmd) { case SNDRV_HWDEP_IOCTL_PVERSION: diff --git a/sound/core/info.c b/sound/core/info.c index 39f9b97d921..ae885392146 100644 --- a/sound/core/info.c +++ b/sound/core/info.c @@ -37,6 +37,8 @@ * */ +#ifdef CONFIG_PROC_FS + int snd_info_check_reserved_words(const char *str) { static char *reserved[] = @@ -66,16 +68,14 @@ int snd_info_check_reserved_words(const char *str) return 1; } -#ifdef CONFIG_PROC_FS - static DECLARE_MUTEX(info_mutex); -typedef struct _snd_info_private_data { - snd_info_buffer_t *rbuffer; - snd_info_buffer_t *wbuffer; - snd_info_entry_t *entry; +struct snd_info_private_data { + struct snd_info_buffer *rbuffer; + struct snd_info_buffer *wbuffer; + struct snd_info_entry *entry; void *file_private_data; -} snd_info_private_data_t; +}; static int snd_info_version_init(void); static int snd_info_version_done(void); @@ -90,7 +90,7 @@ static int snd_info_version_done(void); * * Returns the size of output string. */ -int snd_iprintf(snd_info_buffer_t * buffer, char *fmt,...) +int snd_iprintf(struct snd_info_buffer *buffer, char *fmt,...) { va_list args; int len, res; @@ -115,9 +115,9 @@ int snd_iprintf(snd_info_buffer_t * buffer, char *fmt,...) */ static struct proc_dir_entry *snd_proc_root = NULL; -snd_info_entry_t *snd_seq_root = NULL; +struct snd_info_entry *snd_seq_root = NULL; #ifdef CONFIG_SND_OSSEMUL -snd_info_entry_t *snd_oss_root = NULL; +struct snd_info_entry *snd_oss_root = NULL; #endif static inline void snd_info_entry_prepare(struct proc_dir_entry *de) @@ -134,7 +134,7 @@ static void snd_remove_proc_entry(struct proc_dir_entry *parent, static loff_t snd_info_entry_llseek(struct file *file, loff_t offset, int orig) { - snd_info_private_data_t *data; + struct snd_info_private_data *data; struct snd_info_entry *entry; loff_t ret; @@ -176,9 +176,9 @@ out: static ssize_t snd_info_entry_read(struct file *file, char __user *buffer, size_t count, loff_t * offset) { - snd_info_private_data_t *data; + struct snd_info_private_data *data; struct snd_info_entry *entry; - snd_info_buffer_t *buf; + struct snd_info_buffer *buf; size_t size = 0; loff_t pos; @@ -217,9 +217,9 @@ static ssize_t snd_info_entry_read(struct file *file, char __user *buffer, static ssize_t snd_info_entry_write(struct file *file, const char __user *buffer, size_t count, loff_t * offset) { - snd_info_private_data_t *data; + struct snd_info_private_data *data; struct snd_info_entry *entry; - snd_info_buffer_t *buf; + struct snd_info_buffer *buf; size_t size = 0; loff_t pos; @@ -259,15 +259,15 @@ static ssize_t snd_info_entry_write(struct file *file, const char __user *buffer static int snd_info_entry_open(struct inode *inode, struct file *file) { - snd_info_entry_t *entry; - snd_info_private_data_t *data; - snd_info_buffer_t *buffer; + struct snd_info_entry *entry; + struct snd_info_private_data *data; + struct snd_info_buffer *buffer; struct proc_dir_entry *p; int mode, err; down(&info_mutex); p = PDE(inode); - entry = p == NULL ? NULL : (snd_info_entry_t *)p->data; + entry = p == NULL ? NULL : (struct snd_info_entry *)p->data; if (entry == NULL || entry->disconnected) { up(&info_mutex); return -ENODEV; @@ -381,8 +381,8 @@ static int snd_info_entry_open(struct inode *inode, struct file *file) static int snd_info_entry_release(struct inode *inode, struct file *file) { - snd_info_entry_t *entry; - snd_info_private_data_t *data; + struct snd_info_entry *entry; + struct snd_info_private_data *data; int mode; mode = file->f_flags & O_ACCMODE; @@ -420,7 +420,7 @@ static int snd_info_entry_release(struct inode *inode, struct file *file) static unsigned int snd_info_entry_poll(struct file *file, poll_table * wait) { - snd_info_private_data_t *data; + struct snd_info_private_data *data; struct snd_info_entry *entry; unsigned int mask; @@ -447,7 +447,7 @@ static unsigned int snd_info_entry_poll(struct file *file, poll_table * wait) static inline int _snd_info_entry_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg) { - snd_info_private_data_t *data; + struct snd_info_private_data *data; struct snd_info_entry *entry; data = file->private_data; @@ -479,7 +479,7 @@ static int snd_info_entry_ioctl(struct inode *inode, struct file *file, static int snd_info_entry_mmap(struct file *file, struct vm_area_struct *vma) { struct inode *inode = file->f_dentry->d_inode; - snd_info_private_data_t *data; + struct snd_info_private_data *data; struct snd_info_entry *entry; data = file->private_data; @@ -541,7 +541,7 @@ int __init snd_info_init(void) snd_proc_root = p; #ifdef CONFIG_SND_OSSEMUL { - snd_info_entry_t *entry; + struct snd_info_entry *entry; if ((entry = snd_info_create_module_entry(THIS_MODULE, "oss", NULL)) == NULL) return -ENOMEM; entry->mode = S_IFDIR | S_IRUGO | S_IXUGO; @@ -554,7 +554,7 @@ int __init snd_info_init(void) #endif #if defined(CONFIG_SND_SEQUENCER) || defined(CONFIG_SND_SEQUENCER_MODULE) { - snd_info_entry_t *entry; + struct snd_info_entry *entry; if ((entry = snd_info_create_module_entry(THIS_MODULE, "seq", NULL)) == NULL) return -ENOMEM; entry->mode = S_IFDIR | S_IRUGO | S_IXUGO; @@ -580,12 +580,10 @@ int __exit snd_info_done(void) snd_info_version_done(); if (snd_proc_root) { #if defined(CONFIG_SND_SEQUENCER) || defined(CONFIG_SND_SEQUENCER_MODULE) - if (snd_seq_root) - snd_info_unregister(snd_seq_root); + snd_info_unregister(snd_seq_root); #endif #ifdef CONFIG_SND_OSSEMUL - if (snd_oss_root) - snd_info_unregister(snd_oss_root); + snd_info_unregister(snd_oss_root); #endif snd_remove_proc_entry(&proc_root, snd_proc_root); } @@ -601,10 +599,10 @@ int __exit snd_info_done(void) * create a card proc file * called from init.c */ -int snd_info_card_create(snd_card_t * card) +int snd_info_card_create(struct snd_card *card) { char str[8]; - snd_info_entry_t *entry; + struct snd_info_entry *entry; snd_assert(card != NULL, return -ENXIO); @@ -624,7 +622,7 @@ int snd_info_card_create(snd_card_t * card) * register the card proc file * called from init.c */ -int snd_info_card_register(snd_card_t * card) +int snd_info_card_register(struct snd_card *card) { struct proc_dir_entry *p; @@ -644,7 +642,7 @@ int snd_info_card_register(snd_card_t * card) * de-register the card proc file * called from init.c */ -int snd_info_card_free(snd_card_t * card) +int snd_info_card_free(struct snd_card *card) { snd_assert(card != NULL, return -ENXIO); if (card->proc_root_link) { @@ -669,7 +667,7 @@ int snd_info_card_free(snd_card_t * card) * * Returns zero if successful, or 1 if error or EOF. */ -int snd_info_get_line(snd_info_buffer_t * buffer, char *line, int len) +int snd_info_get_line(struct snd_info_buffer *buffer, char *line, int len) { int c = -1; @@ -747,9 +745,9 @@ char *snd_info_get_str(char *dest, char *src, int len) * * Returns the pointer of the new instance, or NULL on failure. */ -static snd_info_entry_t *snd_info_create_entry(const char *name) +static struct snd_info_entry *snd_info_create_entry(const char *name) { - snd_info_entry_t *entry; + struct snd_info_entry *entry; entry = kzalloc(sizeof(*entry), GFP_KERNEL); if (entry == NULL) return NULL; @@ -774,11 +772,11 @@ static snd_info_entry_t *snd_info_create_entry(const char *name) * * Returns the pointer of the new instance, or NULL on failure. */ -snd_info_entry_t *snd_info_create_module_entry(struct module * module, +struct snd_info_entry *snd_info_create_module_entry(struct module * module, const char *name, - snd_info_entry_t *parent) + struct snd_info_entry *parent) { - snd_info_entry_t *entry = snd_info_create_entry(name); + struct snd_info_entry *entry = snd_info_create_entry(name); if (entry) { entry->module = module; entry->parent = parent; @@ -796,11 +794,11 @@ snd_info_entry_t *snd_info_create_module_entry(struct module * module, * * Returns the pointer of the new instance, or NULL on failure. */ -snd_info_entry_t *snd_info_create_card_entry(snd_card_t * card, +struct snd_info_entry *snd_info_create_card_entry(struct snd_card *card, const char *name, - snd_info_entry_t * parent) + struct snd_info_entry * parent) { - snd_info_entry_t *entry = snd_info_create_entry(name); + struct snd_info_entry *entry = snd_info_create_entry(name); if (entry) { entry->module = card->module; entry->card = card; @@ -809,29 +807,29 @@ snd_info_entry_t *snd_info_create_card_entry(snd_card_t * card, return entry; } -static int snd_info_dev_free_entry(snd_device_t *device) +static int snd_info_dev_free_entry(struct snd_device *device) { - snd_info_entry_t *entry = device->device_data; + struct snd_info_entry *entry = device->device_data; snd_info_free_entry(entry); return 0; } -static int snd_info_dev_register_entry(snd_device_t *device) +static int snd_info_dev_register_entry(struct snd_device *device) { - snd_info_entry_t *entry = device->device_data; + struct snd_info_entry *entry = device->device_data; return snd_info_register(entry); } -static int snd_info_dev_disconnect_entry(snd_device_t *device) +static int snd_info_dev_disconnect_entry(struct snd_device *device) { - snd_info_entry_t *entry = device->device_data; + struct snd_info_entry *entry = device->device_data; entry->disconnected = 1; return 0; } -static int snd_info_dev_unregister_entry(snd_device_t *device) +static int snd_info_dev_unregister_entry(struct snd_device *device) { - snd_info_entry_t *entry = device->device_data; + struct snd_info_entry *entry = device->device_data; return snd_info_unregister(entry); } @@ -855,16 +853,16 @@ static int snd_info_dev_unregister_entry(snd_device_t *device) * * Returns zero if successful, or a negative error code on failure. */ -int snd_card_proc_new(snd_card_t *card, const char *name, - snd_info_entry_t **entryp) +int snd_card_proc_new(struct snd_card *card, const char *name, + struct snd_info_entry **entryp) { - static snd_device_ops_t ops = { + static struct snd_device_ops ops = { .dev_free = snd_info_dev_free_entry, .dev_register = snd_info_dev_register_entry, .dev_disconnect = snd_info_dev_disconnect_entry, .dev_unregister = snd_info_dev_unregister_entry }; - snd_info_entry_t *entry; + struct snd_info_entry *entry; int err; entry = snd_info_create_card_entry(card, name, card->proc_root); @@ -885,7 +883,7 @@ int snd_card_proc_new(snd_card_t *card, const char *name, * * Releases the info entry. Don't call this after registered. */ -void snd_info_free_entry(snd_info_entry_t * entry) +void snd_info_free_entry(struct snd_info_entry * entry) { if (entry == NULL) return; @@ -903,7 +901,7 @@ void snd_info_free_entry(snd_info_entry_t * entry) * * Returns zero if successful, or a negative error code on failure. */ -int snd_info_register(snd_info_entry_t * entry) +int snd_info_register(struct snd_info_entry * entry) { struct proc_dir_entry *root, *p = NULL; @@ -933,11 +931,12 @@ int snd_info_register(snd_info_entry_t * entry) * * Returns zero if successful, or a negative error code on failure. */ -int snd_info_unregister(snd_info_entry_t * entry) +int snd_info_unregister(struct snd_info_entry * entry) { struct proc_dir_entry *root; - snd_assert(entry != NULL, return -ENXIO); + if (! entry) + return 0; snd_assert(entry->p != NULL, return -ENXIO); root = entry->parent == NULL ? snd_proc_root : entry->parent->p; snd_assert(root, return -ENXIO); @@ -952,9 +951,9 @@ int snd_info_unregister(snd_info_entry_t * entry) */ -static snd_info_entry_t *snd_info_version_entry = NULL; +static struct snd_info_entry *snd_info_version_entry = NULL; -static void snd_info_version_read(snd_info_entry_t *entry, snd_info_buffer_t * buffer) +static void snd_info_version_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer) { snd_iprintf(buffer, "Advanced Linux Sound Architecture Driver Version " @@ -964,7 +963,7 @@ static void snd_info_version_read(snd_info_entry_t *entry, snd_info_buffer_t * b static int __init snd_info_version_init(void) { - snd_info_entry_t *entry; + struct snd_info_entry *entry; entry = snd_info_create_module_entry(THIS_MODULE, "version", NULL); if (entry == NULL) diff --git a/sound/core/info_oss.c b/sound/core/info_oss.c index 12107968d40..820f4772e44 100644 --- a/sound/core/info_oss.c +++ b/sound/core/info_oss.c @@ -37,7 +37,7 @@ static DECLARE_MUTEX(strings); static char *snd_sndstat_strings[SNDRV_CARDS][SNDRV_OSS_INFO_DEV_COUNT]; -static snd_info_entry_t *snd_sndstat_proc_entry; +static struct snd_info_entry *snd_sndstat_proc_entry; int snd_oss_info_register(int dev, int num, char *string) { @@ -63,9 +63,9 @@ int snd_oss_info_register(int dev, int num, char *string) return 0; } -extern void snd_card_info_read_oss(snd_info_buffer_t * buffer); +extern void snd_card_info_read_oss(struct snd_info_buffer *buffer); -static int snd_sndstat_show_strings(snd_info_buffer_t * buf, char *id, int dev) +static int snd_sndstat_show_strings(struct snd_info_buffer *buf, char *id, int dev) { int idx, ok = -1; char *str; @@ -88,7 +88,8 @@ static int snd_sndstat_show_strings(snd_info_buffer_t * buf, char *id, int dev) return ok; } -static void snd_sndstat_proc_read(snd_info_entry_t *entry, snd_info_buffer_t * buffer) +static void snd_sndstat_proc_read(struct snd_info_entry *entry, + struct snd_info_buffer *buffer) { snd_iprintf(buffer, "Sound Driver:3.8.1a-980706 (ALSA v" CONFIG_SND_VERSION " emulation code)\n"); snd_iprintf(buffer, "Kernel: %s %s %s %s %s\n", @@ -111,7 +112,7 @@ static void snd_sndstat_proc_read(snd_info_entry_t *entry, snd_info_buffer_t * b int snd_info_minor_register(void) { - snd_info_entry_t *entry; + struct snd_info_entry *entry; memset(snd_sndstat_strings, 0, sizeof(snd_sndstat_strings)); if ((entry = snd_info_create_module_entry(THIS_MODULE, "sndstat", snd_oss_root)) != NULL) { diff --git a/sound/core/init.c b/sound/core/init.c index 33813f92ab5..75816688607 100644 --- a/sound/core/init.c +++ b/sound/core/init.c @@ -28,7 +28,6 @@ #include <linux/ctype.h> #include <linux/pci.h> #include <linux/pm.h> -#include <linux/platform_device.h> #include <sound/core.h> #include <sound/control.h> @@ -40,18 +39,46 @@ struct snd_shutdown_f_ops { }; unsigned int snd_cards_lock = 0; /* locked for registering/using */ -snd_card_t *snd_cards[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS-1)] = NULL}; +struct snd_card *snd_cards[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS-1)] = NULL}; DEFINE_RWLOCK(snd_card_rwlock); #if defined(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS_MODULE) -int (*snd_mixer_oss_notify_callback)(snd_card_t *card, int free_flag); +int (*snd_mixer_oss_notify_callback)(struct snd_card *card, int free_flag); #endif -static void snd_card_id_read(snd_info_entry_t *entry, snd_info_buffer_t * buffer) +#ifdef CONFIG_PROC_FS +static void snd_card_id_read(struct snd_info_entry *entry, + struct snd_info_buffer *buffer) { snd_iprintf(buffer, "%s\n", entry->card->id); } +static inline int init_info_for_card(struct snd_card *card) +{ + int err; + struct snd_info_entry *entry; + + if ((err = snd_info_card_register(card)) < 0) { + snd_printd("unable to create card info\n"); + return err; + } + if ((entry = snd_info_create_card_entry(card, "id", card->proc_root)) == NULL) { + snd_printd("unable to create card entry\n"); + return err; + } + entry->c.text.read_size = PAGE_SIZE; + entry->c.text.read = snd_card_id_read; + if (snd_info_register(entry) < 0) { + snd_info_free_entry(entry); + entry = NULL; + } + card->proc_id = entry; + return 0; +} +#else /* !CONFIG_PROC_FS */ +#define init_info_for_card(card) +#endif + static void snd_card_free_thread(void * __card); /** @@ -63,13 +90,13 @@ static void snd_card_free_thread(void * __card); * * Creates and initializes a soundcard structure. * - * Returns kmallocated snd_card_t structure. Creates the ALSA control interface + * Returns kmallocated snd_card structure. Creates the ALSA control interface * (which is blocked until snd_card_register function is called). */ -snd_card_t *snd_card_new(int idx, const char *xid, +struct snd_card *snd_card_new(int idx, const char *xid, struct module *module, int extra_size) { - snd_card_t *card; + struct snd_card *card; int err; if (extra_size < 0) @@ -132,7 +159,7 @@ snd_card_t *snd_card_new(int idx, const char *xid, goto __error_ctl; } if (extra_size > 0) - card->private_data = (char *)card + sizeof(snd_card_t); + card->private_data = (char *)card + sizeof(struct snd_card); return card; __error_ctl: @@ -158,7 +185,7 @@ static unsigned int snd_disconnect_poll(struct file * file, poll_table * wait) * Note: The current implementation replaces all active file->f_op with special * dummy file operations (they do nothing except release). */ -int snd_card_disconnect(snd_card_t * card) +int snd_card_disconnect(struct snd_card *card) { struct snd_monitor_file *mfile; struct file *file; @@ -228,12 +255,6 @@ int snd_card_disconnect(snd_card_t * card) return 0; } -#ifdef CONFIG_SND_GENERIC_DRIVER -static void snd_generic_device_unregister(snd_card_t *card); -#else -#define snd_generic_device_unregister(x) /*NOP*/ -#endif - /** * snd_card_free - frees given soundcard structure * @card: soundcard structure @@ -245,7 +266,7 @@ static void snd_generic_device_unregister(snd_card_t *card); * Returns zero. Frees all associated devices and frees the control * interface associated to given soundcard. */ -int snd_card_free(snd_card_t * card) +int snd_card_free(struct snd_card *card) { struct snd_shutdown_f_ops *s_f_ops; @@ -279,13 +300,11 @@ int snd_card_free(snd_card_t * card) } if (card->private_free) card->private_free(card); - if (card->proc_id) - snd_info_unregister(card->proc_id); + snd_info_unregister(card->proc_id); if (snd_info_card_free(card) < 0) { snd_printk(KERN_WARNING "unable to free card info\n"); /* Not fatal error */ } - snd_generic_device_unregister(card); while (card->s_f_ops) { s_f_ops = card->s_f_ops; card->s_f_ops = s_f_ops->next; @@ -300,7 +319,7 @@ int snd_card_free(snd_card_t * card) static void snd_card_free_thread(void * __card) { - snd_card_t *card = __card; + struct snd_card *card = __card; struct module * module = card->module; if (!try_module_get(module)) { @@ -327,7 +346,7 @@ static void snd_card_free_thread(void * __card) * * Returns - zero otherwise a negative error code if the start of thread failed. */ -int snd_card_free_in_thread(snd_card_t * card) +int snd_card_free_in_thread(struct snd_card *card) { if (card->files == NULL) { snd_card_free(card); @@ -343,9 +362,9 @@ int snd_card_free_in_thread(snd_card_t * card) return -EFAULT; } -static void choose_default_id(snd_card_t * card) +static void choose_default_id(struct snd_card *card) { - int i, len, idx_flag = 0, loops = 8; + int i, len, idx_flag = 0, loops = SNDRV_CARDS; char *id, *spos; id = spos = card->shortname; @@ -387,9 +406,12 @@ static void choose_default_id(snd_card_t * card) __change: len = strlen(id); - if (idx_flag) - id[len-1]++; - else if ((size_t)len <= sizeof(card->id) - 3) { + if (idx_flag) { + if (id[len-1] != '9') + id[len-1]++; + else + id[len-1] = 'A'; + } else if ((size_t)len <= sizeof(card->id) - 3) { strcat(id, "_1"); idx_flag++; } else { @@ -415,10 +437,9 @@ static void choose_default_id(snd_card_t * card) * * Returns zero otherwise a negative error code if the registrain failed. */ -int snd_card_register(snd_card_t * card) +int snd_card_register(struct snd_card *card) { int err; - snd_info_entry_t *entry; snd_assert(card != NULL, return -EINVAL); if ((err = snd_device_register_all(card)) < 0) @@ -433,22 +454,7 @@ int snd_card_register(snd_card_t * card) choose_default_id(card); snd_cards[card->number] = card; write_unlock(&snd_card_rwlock); - if ((err = snd_info_card_register(card)) < 0) { - snd_printd("unable to create card info\n"); - goto __skip_info; - } - if ((entry = snd_info_create_card_entry(card, "id", card->proc_root)) == NULL) { - snd_printd("unable to create card entry\n"); - goto __skip_info; - } - entry->c.text.read_size = PAGE_SIZE; - entry->c.text.read = snd_card_id_read; - if (snd_info_register(entry) < 0) { - snd_info_free_entry(entry); - entry = NULL; - } - card->proc_id = entry; - __skip_info: + init_info_for_card(card); #if defined(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS_MODULE) if (snd_mixer_oss_notify_callback) snd_mixer_oss_notify_callback(card, SND_MIXER_OSS_NOTIFY_REGISTER); @@ -456,23 +462,25 @@ int snd_card_register(snd_card_t * card) return 0; } -static snd_info_entry_t *snd_card_info_entry = NULL; +#ifdef CONFIG_PROC_FS +static struct snd_info_entry *snd_card_info_entry = NULL; -static void snd_card_info_read(snd_info_entry_t *entry, snd_info_buffer_t * buffer) +static void snd_card_info_read(struct snd_info_entry *entry, + struct snd_info_buffer *buffer) { int idx, count; - snd_card_t *card; + struct snd_card *card; for (idx = count = 0; idx < SNDRV_CARDS; idx++) { read_lock(&snd_card_rwlock); if ((card = snd_cards[idx]) != NULL) { count++; - snd_iprintf(buffer, "%i [%-15s]: %s - %s\n", + snd_iprintf(buffer, "%2i [%-15s]: %s - %s\n", idx, card->id, card->driver, card->shortname); - snd_iprintf(buffer, " %s\n", + snd_iprintf(buffer, " %s\n", card->longname); } read_unlock(&snd_card_rwlock); @@ -481,12 +489,12 @@ static void snd_card_info_read(snd_info_entry_t *entry, snd_info_buffer_t * buff snd_iprintf(buffer, "--- no soundcards ---\n"); } -#if defined(CONFIG_SND_OSSEMUL) && defined(CONFIG_PROC_FS) +#ifdef CONFIG_SND_OSSEMUL -void snd_card_info_read_oss(snd_info_buffer_t * buffer) +void snd_card_info_read_oss(struct snd_info_buffer *buffer) { int idx, count; - snd_card_t *card; + struct snd_card *card; for (idx = count = 0; idx < SNDRV_CARDS; idx++) { read_lock(&snd_card_rwlock); @@ -504,16 +512,18 @@ void snd_card_info_read_oss(snd_info_buffer_t * buffer) #endif #ifdef MODULE -static snd_info_entry_t *snd_card_module_info_entry; -static void snd_card_module_info_read(snd_info_entry_t *entry, snd_info_buffer_t * buffer) +static struct snd_info_entry *snd_card_module_info_entry; +static void snd_card_module_info_read(struct snd_info_entry *entry, + struct snd_info_buffer *buffer) { int idx; - snd_card_t *card; + struct snd_card *card; for (idx = 0; idx < SNDRV_CARDS; idx++) { read_lock(&snd_card_rwlock); if ((card = snd_cards[idx]) != NULL) - snd_iprintf(buffer, "%i %s\n", idx, card->module->name); + snd_iprintf(buffer, "%2i %s\n", + idx, card->module->name); read_unlock(&snd_card_rwlock); } } @@ -521,7 +531,7 @@ static void snd_card_module_info_read(snd_info_entry_t *entry, snd_info_buffer_t int __init snd_card_info_init(void) { - snd_info_entry_t *entry; + struct snd_info_entry *entry; entry = snd_info_create_module_entry(THIS_MODULE, "cards", NULL); if (! entry) @@ -551,15 +561,15 @@ int __init snd_card_info_init(void) int __exit snd_card_info_done(void) { - if (snd_card_info_entry) - snd_info_unregister(snd_card_info_entry); + snd_info_unregister(snd_card_info_entry); #ifdef MODULE - if (snd_card_module_info_entry) - snd_info_unregister(snd_card_module_info_entry); + snd_info_unregister(snd_card_module_info_entry); #endif return 0; } +#endif /* CONFIG_PROC_FS */ + /** * snd_component_add - add a component string * @card: soundcard structure @@ -571,7 +581,7 @@ int __exit snd_card_info_done(void) * Returns zero otherwise a negative error code. */ -int snd_component_add(snd_card_t *card, const char *component) +int snd_component_add(struct snd_card *card, const char *component) { char *ptr; int len = strlen(component); @@ -602,7 +612,7 @@ int snd_component_add(snd_card_t *card, const char *component) * * Returns zero or a negative error code. */ -int snd_card_file_add(snd_card_t *card, struct file *file) +int snd_card_file_add(struct snd_card *card, struct file *file) { struct snd_monitor_file *mfile; @@ -636,7 +646,7 @@ int snd_card_file_add(snd_card_t *card, struct file *file) * * Returns zero or a negative error code. */ -int snd_card_file_remove(snd_card_t *card, struct file *file) +int snd_card_file_remove(struct snd_card *card, struct file *file) { struct snd_monitor_file *mfile, *pfile = NULL; @@ -664,97 +674,6 @@ int snd_card_file_remove(snd_card_t *card, struct file *file) return 0; } -#ifdef CONFIG_SND_GENERIC_DRIVER -/* - * generic device without a proper bus using platform_device - * (e.g. ISA) - */ -struct snd_generic_device { - struct platform_device pdev; - snd_card_t *card; -}; - -#define get_snd_generic_card(dev) container_of(dev, struct snd_generic_device, pdev)->card - -#define SND_GENERIC_NAME "snd_generic" - -#ifdef CONFIG_PM -static int snd_generic_suspend(struct platform_device *dev, pm_message_t state); -static int snd_generic_resume(struct platform_device *dev); -#endif - -/* initialized in sound.c */ -struct platform_driver snd_generic_driver = { -#ifdef CONFIG_PM - .suspend = snd_generic_suspend, - .resume = snd_generic_resume, -#endif - .driver = { - .name = SND_GENERIC_NAME, - }, -}; - -void snd_generic_device_release(struct device *dev) -{ -} - -static int snd_generic_device_register(snd_card_t *card) -{ - struct snd_generic_device *dev; - int err; - - if (card->generic_dev) - return 0; /* already registered */ - - dev = kzalloc(sizeof(*dev), GFP_KERNEL); - if (! dev) { - snd_printk(KERN_ERR "can't allocate generic_device\n"); - return -ENOMEM; - } - - dev->pdev.name = SND_GENERIC_NAME; - dev->pdev.id = card->number; - dev->pdev.dev.release = snd_generic_device_release; - dev->card = card; - if ((err = platform_device_register(&dev->pdev)) < 0) { - kfree(dev); - return err; - } - card->generic_dev = dev; - return 0; -} - -static void snd_generic_device_unregister(snd_card_t *card) -{ - struct snd_generic_device *dev = card->generic_dev; - if (dev) { - platform_device_unregister(&dev->pdev); - kfree(dev); - card->generic_dev = NULL; - } -} - -/** - * snd_card_set_generic_dev - assign the generic device to the card - * @card: soundcard structure - * - * Assigns a generic device to the card. This function is provided as the - * last resort, for devices without any proper bus. Thus this won't override - * the device already assigned to the card. - * - * Returns zero if successful, or a negative error code. - */ -int snd_card_set_generic_dev(snd_card_t *card) -{ - int err; - if ((err = snd_generic_device_register(card)) < 0) - return err; - if (! card->dev) - snd_card_set_dev(card, &card->generic_dev->pdev.dev); - return 0; -} -#endif /* CONFIG_SND_GENERIC_DRIVER */ - #ifdef CONFIG_PM /** * snd_power_wait - wait until the power-state is changed. @@ -766,7 +685,7 @@ int snd_card_set_generic_dev(snd_card_t *card) * * Note: the power lock must be active before call. */ -int snd_power_wait(snd_card_t *card, unsigned int power_state, struct file *file) +int snd_power_wait(struct snd_card *card, unsigned int power_state, struct file *file) { wait_queue_t wait; int result = 0; @@ -798,107 +717,4 @@ int snd_power_wait(snd_card_t *card, unsigned int power_state, struct file *file return result; } -/** - * snd_card_set_pm_callback - set the PCI power-management callbacks - * @card: soundcard structure - * @suspend: suspend callback function - * @resume: resume callback function - * @private_data: private data to pass to the callback functions - * - * Sets the power-management callback functions of the card. - * These callbacks are called from ALSA's common PCI suspend/resume - * handler and from the control API. - */ -int snd_card_set_pm_callback(snd_card_t *card, - int (*suspend)(snd_card_t *, pm_message_t), - int (*resume)(snd_card_t *), - void *private_data) -{ - card->pm_suspend = suspend; - card->pm_resume = resume; - card->pm_private_data = private_data; - return 0; -} - -#ifdef CONFIG_SND_GENERIC_DRIVER -/* suspend/resume callbacks for snd_generic platform device */ -static int snd_generic_suspend(struct platform_device *dev, pm_message_t state) -{ - snd_card_t *card; - - card = get_snd_generic_card(dev); - if (card->power_state == SNDRV_CTL_POWER_D3hot) - return 0; - if (card->pm_suspend) - card->pm_suspend(card, PMSG_SUSPEND); - snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); - return 0; -} - -static int snd_generic_resume(struct platform_device *dev) -{ - snd_card_t *card; - - card = get_snd_generic_card(dev); - if (card->power_state == SNDRV_CTL_POWER_D0) - return 0; - if (card->pm_resume) - card->pm_resume(card); - snd_power_change_state(card, SNDRV_CTL_POWER_D0); - return 0; -} - -/** - * snd_card_set_generic_pm_callback - set the generic power-management callbacks - * @card: soundcard structure - * @suspend: suspend callback function - * @resume: resume callback function - * @private_data: private data to pass to the callback functions - * - * Registers the power-management and sets the lowlevel callbacks for - * the given card. These callbacks are called from the ALSA's common - * PM handler and from the control API. - */ -int snd_card_set_generic_pm_callback(snd_card_t *card, - int (*suspend)(snd_card_t *, pm_message_t), - int (*resume)(snd_card_t *), - void *private_data) -{ - int err; - if ((err = snd_generic_device_register(card)) < 0) - return err; - return snd_card_set_pm_callback(card, suspend, resume, private_data); -} -#endif /* CONFIG_SND_GENERIC_DRIVER */ - -#ifdef CONFIG_PCI -int snd_card_pci_suspend(struct pci_dev *dev, pm_message_t state) -{ - snd_card_t *card = pci_get_drvdata(dev); - int err; - if (! card || ! card->pm_suspend) - return 0; - if (card->power_state == SNDRV_CTL_POWER_D3hot) - return 0; - err = card->pm_suspend(card, PMSG_SUSPEND); - pci_save_state(dev); - snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); - return err; -} - -int snd_card_pci_resume(struct pci_dev *dev) -{ - snd_card_t *card = pci_get_drvdata(dev); - if (! card || ! card->pm_resume) - return 0; - if (card->power_state == SNDRV_CTL_POWER_D0) - return 0; - /* restore the PCI config space */ - pci_restore_state(dev); - card->pm_resume(card); - snd_power_change_state(card, SNDRV_CTL_POWER_D0); - return 0; -} -#endif - #endif /* CONFIG_PM */ diff --git a/sound/core/memalloc.c b/sound/core/memalloc.c index e4b8959dd4b..19b3dcbb09c 100644 --- a/sound/core/memalloc.c +++ b/sound/core/memalloc.c @@ -43,10 +43,6 @@ MODULE_DESCRIPTION("Memory allocator for ALSA system."); MODULE_LICENSE("GPL"); -#ifndef SNDRV_CARDS -#define SNDRV_CARDS 8 -#endif - /* */ diff --git a/sound/core/oss/copy.c b/sound/core/oss/copy.c index edecbe7417b..d6a04c2d5a7 100644 --- a/sound/core/oss/copy.c +++ b/sound/core/oss/copy.c @@ -25,9 +25,9 @@ #include <sound/pcm.h> #include "pcm_plugin.h" -static snd_pcm_sframes_t copy_transfer(snd_pcm_plugin_t *plugin, - const snd_pcm_plugin_channel_t *src_channels, - snd_pcm_plugin_channel_t *dst_channels, +static snd_pcm_sframes_t copy_transfer(struct snd_pcm_plugin *plugin, + const struct snd_pcm_plugin_channel *src_channels, + struct snd_pcm_plugin_channel *dst_channels, snd_pcm_uframes_t frames) { unsigned int channel; @@ -58,13 +58,13 @@ static snd_pcm_sframes_t copy_transfer(snd_pcm_plugin_t *plugin, return frames; } -int snd_pcm_plugin_build_copy(snd_pcm_plug_t *plug, - snd_pcm_plugin_format_t *src_format, - snd_pcm_plugin_format_t *dst_format, - snd_pcm_plugin_t **r_plugin) +int snd_pcm_plugin_build_copy(struct snd_pcm_substream *plug, + struct snd_pcm_plugin_format *src_format, + struct snd_pcm_plugin_format *dst_format, + struct snd_pcm_plugin **r_plugin) { int err; - snd_pcm_plugin_t *plugin; + struct snd_pcm_plugin *plugin; int width; snd_assert(r_plugin != NULL, return -ENXIO); diff --git a/sound/core/oss/io.c b/sound/core/oss/io.c index bb1c99a5b73..322702e05f3 100644 --- a/sound/core/oss/io.c +++ b/sound/core/oss/io.c @@ -35,9 +35,9 @@ * Basic io plugin */ -static snd_pcm_sframes_t io_playback_transfer(snd_pcm_plugin_t *plugin, - const snd_pcm_plugin_channel_t *src_channels, - snd_pcm_plugin_channel_t *dst_channels ATTRIBUTE_UNUSED, +static snd_pcm_sframes_t io_playback_transfer(struct snd_pcm_plugin *plugin, + const struct snd_pcm_plugin_channel *src_channels, + struct snd_pcm_plugin_channel *dst_channels, snd_pcm_uframes_t frames) { snd_assert(plugin != NULL, return -ENXIO); @@ -58,9 +58,9 @@ static snd_pcm_sframes_t io_playback_transfer(snd_pcm_plugin_t *plugin, } } -static snd_pcm_sframes_t io_capture_transfer(snd_pcm_plugin_t *plugin, - const snd_pcm_plugin_channel_t *src_channels ATTRIBUTE_UNUSED, - snd_pcm_plugin_channel_t *dst_channels, +static snd_pcm_sframes_t io_capture_transfer(struct snd_pcm_plugin *plugin, + const struct snd_pcm_plugin_channel *src_channels, + struct snd_pcm_plugin_channel *dst_channels, snd_pcm_uframes_t frames) { snd_assert(plugin != NULL, return -ENXIO); @@ -82,13 +82,13 @@ static snd_pcm_sframes_t io_capture_transfer(snd_pcm_plugin_t *plugin, return 0; } -static snd_pcm_sframes_t io_src_channels(snd_pcm_plugin_t *plugin, +static snd_pcm_sframes_t io_src_channels(struct snd_pcm_plugin *plugin, snd_pcm_uframes_t frames, - snd_pcm_plugin_channel_t **channels) + struct snd_pcm_plugin_channel **channels) { int err; unsigned int channel; - snd_pcm_plugin_channel_t *v; + struct snd_pcm_plugin_channel *v; err = snd_pcm_plugin_client_channels(plugin, frames, &v); if (err < 0) return err; @@ -100,13 +100,13 @@ static snd_pcm_sframes_t io_src_channels(snd_pcm_plugin_t *plugin, return frames; } -int snd_pcm_plugin_build_io(snd_pcm_plug_t *plug, - snd_pcm_hw_params_t *params, - snd_pcm_plugin_t **r_plugin) +int snd_pcm_plugin_build_io(struct snd_pcm_substream *plug, + struct snd_pcm_hw_params *params, + struct snd_pcm_plugin **r_plugin) { int err; - snd_pcm_plugin_format_t format; - snd_pcm_plugin_t *plugin; + struct snd_pcm_plugin_format format; + struct snd_pcm_plugin *plugin; snd_assert(r_plugin != NULL, return -ENXIO); *r_plugin = NULL; diff --git a/sound/core/oss/linear.c b/sound/core/oss/linear.c index 12ed27a57b2..8cbfa415ce4 100644 --- a/sound/core/oss/linear.c +++ b/sound/core/oss/linear.c @@ -30,19 +30,19 @@ * Basic linear conversion plugin */ -typedef struct linear_private_data { +struct linear_priv { int conv; -} linear_t; +}; -static void convert(snd_pcm_plugin_t *plugin, - const snd_pcm_plugin_channel_t *src_channels, - snd_pcm_plugin_channel_t *dst_channels, +static void convert(struct snd_pcm_plugin *plugin, + const struct snd_pcm_plugin_channel *src_channels, + struct snd_pcm_plugin_channel *dst_channels, snd_pcm_uframes_t frames) { #define CONV_LABELS #include "plugin_ops.h" #undef CONV_LABELS - linear_t *data = (linear_t *)plugin->extra_data; + struct linear_priv *data = (struct linear_priv *)plugin->extra_data; void *conv = conv_labels[data->conv]; int channel; int nchannels = plugin->src_format.channels; @@ -75,15 +75,15 @@ static void convert(snd_pcm_plugin_t *plugin, } } -static snd_pcm_sframes_t linear_transfer(snd_pcm_plugin_t *plugin, - const snd_pcm_plugin_channel_t *src_channels, - snd_pcm_plugin_channel_t *dst_channels, +static snd_pcm_sframes_t linear_transfer(struct snd_pcm_plugin *plugin, + const struct snd_pcm_plugin_channel *src_channels, + struct snd_pcm_plugin_channel *dst_channels, snd_pcm_uframes_t frames) { - linear_t *data; + struct linear_priv *data; snd_assert(plugin != NULL && src_channels != NULL && dst_channels != NULL, return -ENXIO); - data = (linear_t *)plugin->extra_data; + data = (struct linear_priv *)plugin->extra_data; if (frames == 0) return 0; #ifdef CONFIG_SND_DEBUG @@ -128,14 +128,14 @@ int conv_index(int src_format, int dst_format) return src_width * 32 + src_endian * 16 + sign * 8 + dst_width * 2 + dst_endian; } -int snd_pcm_plugin_build_linear(snd_pcm_plug_t *plug, - snd_pcm_plugin_format_t *src_format, - snd_pcm_plugin_format_t *dst_format, - snd_pcm_plugin_t **r_plugin) +int snd_pcm_plugin_build_linear(struct snd_pcm_substream *plug, + struct snd_pcm_plugin_format *src_format, + struct snd_pcm_plugin_format *dst_format, + struct snd_pcm_plugin **r_plugin) { int err; - struct linear_private_data *data; - snd_pcm_plugin_t *plugin; + struct linear_priv *data; + struct snd_pcm_plugin *plugin; snd_assert(r_plugin != NULL, return -ENXIO); *r_plugin = NULL; @@ -147,10 +147,10 @@ int snd_pcm_plugin_build_linear(snd_pcm_plug_t *plug, err = snd_pcm_plugin_build(plug, "linear format conversion", src_format, dst_format, - sizeof(linear_t), &plugin); + sizeof(struct linear_priv), &plugin); if (err < 0) return err; - data = (linear_t *)plugin->extra_data; + data = (struct linear_priv *)plugin->extra_data; data->conv = conv_index(src_format->format, dst_format->format); plugin->transfer = linear_transfer; *r_plugin = plugin; diff --git a/sound/core/oss/mixer_oss.c b/sound/core/oss/mixer_oss.c index 214933cf5d4..f08e65a2bff 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)); - 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) + 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; @@ -71,10 +72,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 +83,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 +99,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 +114,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 +126,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 +142,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 +158,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 +168,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 +179,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 +192,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 +207,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 +244,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 +269,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 +294,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 +363,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,12 +399,6 @@ static struct file_operations snd_mixer_oss_f_ops = .compat_ioctl = snd_mixer_oss_ioctl_compat, }; -static snd_minor_t snd_mixer_oss_reg = -{ - .comment = "mixer", - .f_ops = &snd_mixer_oss_f_ops, -}; - /* * utilities */ @@ -432,16 +427,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 +483,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 +495,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 +532,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 +571,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 +597,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 +635,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 +680,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 +718,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 +731,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 +744,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 +754,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 +764,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 +813,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 +873,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 +905,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 +917,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 +931,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 +986,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) { @@ -1058,6 +1053,7 @@ static int snd_mixer_oss_build_input(snd_mixer_oss_t *mixer, struct snd_mixer_os return 0; } +#ifdef CONFIG_PROC_FS /* */ #define MIXER_VOL(name) [SOUND_MIXER_##name] = #name @@ -1093,10 +1089,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 +1113,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 +1172,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,15 +1194,19 @@ 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); 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(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]; @@ -1292,7 +1292,7 @@ static int snd_mixer_oss_notify_handler(snd_card_t * 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, 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/mulaw.c b/sound/core/oss/mulaw.c index 44ec4c66eb1..14f5578ec7a 100644 --- a/sound/core/oss/mulaw.c +++ b/sound/core/oss/mulaw.c @@ -139,25 +139,25 @@ static int ulaw2linear(unsigned char u_val) * Basic Mu-Law plugin */ -typedef void (*mulaw_f)(snd_pcm_plugin_t *plugin, - const snd_pcm_plugin_channel_t *src_channels, - snd_pcm_plugin_channel_t *dst_channels, +typedef void (*mulaw_f)(struct snd_pcm_plugin *plugin, + const struct snd_pcm_plugin_channel *src_channels, + struct snd_pcm_plugin_channel *dst_channels, snd_pcm_uframes_t frames); -typedef struct mulaw_private_data { +struct mulaw_priv { mulaw_f func; int conv; -} mulaw_t; +}; -static void mulaw_decode(snd_pcm_plugin_t *plugin, - const snd_pcm_plugin_channel_t *src_channels, - snd_pcm_plugin_channel_t *dst_channels, +static void mulaw_decode(struct snd_pcm_plugin *plugin, + const struct snd_pcm_plugin_channel *src_channels, + struct snd_pcm_plugin_channel *dst_channels, snd_pcm_uframes_t frames) { #define PUT_S16_LABELS #include "plugin_ops.h" #undef PUT_S16_LABELS - mulaw_t *data = (mulaw_t *)plugin->extra_data; + struct mulaw_priv *data = (struct mulaw_priv *)plugin->extra_data; void *put = put_s16_labels[data->conv]; int channel; int nchannels = plugin->src_format.channels; @@ -191,15 +191,15 @@ static void mulaw_decode(snd_pcm_plugin_t *plugin, } } -static void mulaw_encode(snd_pcm_plugin_t *plugin, - const snd_pcm_plugin_channel_t *src_channels, - snd_pcm_plugin_channel_t *dst_channels, +static void mulaw_encode(struct snd_pcm_plugin *plugin, + const struct snd_pcm_plugin_channel *src_channels, + struct snd_pcm_plugin_channel *dst_channels, snd_pcm_uframes_t frames) { #define GET_S16_LABELS #include "plugin_ops.h" #undef GET_S16_LABELS - mulaw_t *data = (mulaw_t *)plugin->extra_data; + struct mulaw_priv *data = (struct mulaw_priv *)plugin->extra_data; void *get = get_s16_labels[data->conv]; int channel; int nchannels = plugin->src_format.channels; @@ -234,12 +234,12 @@ static void mulaw_encode(snd_pcm_plugin_t *plugin, } } -static snd_pcm_sframes_t mulaw_transfer(snd_pcm_plugin_t *plugin, - const snd_pcm_plugin_channel_t *src_channels, - snd_pcm_plugin_channel_t *dst_channels, +static snd_pcm_sframes_t mulaw_transfer(struct snd_pcm_plugin *plugin, + const struct snd_pcm_plugin_channel *src_channels, + struct snd_pcm_plugin_channel *dst_channels, snd_pcm_uframes_t frames) { - mulaw_t *data; + struct mulaw_priv *data; snd_assert(plugin != NULL && src_channels != NULL && dst_channels != NULL, return -ENXIO); if (frames == 0) @@ -257,20 +257,20 @@ static snd_pcm_sframes_t mulaw_transfer(snd_pcm_plugin_t *plugin, } } #endif - data = (mulaw_t *)plugin->extra_data; + data = (struct mulaw_priv *)plugin->extra_data; data->func(plugin, src_channels, dst_channels, frames); return frames; } -int snd_pcm_plugin_build_mulaw(snd_pcm_plug_t *plug, - snd_pcm_plugin_format_t *src_format, - snd_pcm_plugin_format_t *dst_format, - snd_pcm_plugin_t **r_plugin) +int snd_pcm_plugin_build_mulaw(struct snd_pcm_substream *plug, + struct snd_pcm_plugin_format *src_format, + struct snd_pcm_plugin_format *dst_format, + struct snd_pcm_plugin **r_plugin) { int err; - mulaw_t *data; - snd_pcm_plugin_t *plugin; - snd_pcm_plugin_format_t *format; + struct mulaw_priv *data; + struct snd_pcm_plugin *plugin; + struct snd_pcm_plugin_format *format; mulaw_f func; snd_assert(r_plugin != NULL, return -ENXIO); @@ -295,10 +295,10 @@ int snd_pcm_plugin_build_mulaw(snd_pcm_plug_t *plug, err = snd_pcm_plugin_build(plug, "Mu-Law<->linear conversion", src_format, dst_format, - sizeof(mulaw_t), &plugin); + sizeof(struct mulaw_priv), &plugin); if (err < 0) return err; - data = (mulaw_t*)plugin->extra_data; + data = (struct mulaw_priv *)plugin->extra_data; data->func = func; data->conv = getput_index(format->format); snd_assert(data->conv >= 0 && data->conv < 4*2*2, return -EINVAL); diff --git a/sound/core/oss/pcm_oss.c b/sound/core/oss/pcm_oss.c index bcc97075913..7fd072392c7 100644 --- a/sound/core/oss/pcm_oss.c +++ b/sound/core/oss/pcm_oss.c @@ -61,10 +61,10 @@ MODULE_PARM_DESC(nonblock_open, "Don't block opening busy PCM devices."); MODULE_ALIAS_SNDRV_MINOR(SNDRV_MINOR_OSS_PCM); MODULE_ALIAS_SNDRV_MINOR(SNDRV_MINOR_OSS_PCM1); -extern int snd_mixer_oss_ioctl_card(snd_card_t *card, unsigned int cmd, unsigned long arg); -static int snd_pcm_oss_get_rate(snd_pcm_oss_file_t *pcm_oss_file); -static int snd_pcm_oss_get_channels(snd_pcm_oss_file_t *pcm_oss_file); -static int snd_pcm_oss_get_format(snd_pcm_oss_file_t *pcm_oss_file); +extern int snd_mixer_oss_ioctl_card(struct snd_card *card, unsigned int cmd, unsigned long arg); +static int snd_pcm_oss_get_rate(struct snd_pcm_oss_file *pcm_oss_file); +static int snd_pcm_oss_get_channels(struct snd_pcm_oss_file *pcm_oss_file); +static int snd_pcm_oss_get_format(struct snd_pcm_oss_file *pcm_oss_file); static inline mm_segment_t snd_enter_user(void) { @@ -78,10 +78,10 @@ static inline void snd_leave_user(mm_segment_t fs) set_fs(fs); } -static int snd_pcm_oss_plugin_clear(snd_pcm_substream_t *substream) +static int snd_pcm_oss_plugin_clear(struct snd_pcm_substream *substream) { - snd_pcm_runtime_t *runtime = substream->runtime; - snd_pcm_plugin_t *plugin, *next; + struct snd_pcm_runtime *runtime = substream->runtime; + struct snd_pcm_plugin *plugin, *next; plugin = runtime->oss.plugin_first; while (plugin) { @@ -93,9 +93,9 @@ static int snd_pcm_oss_plugin_clear(snd_pcm_substream_t *substream) return 0; } -static int snd_pcm_plugin_insert(snd_pcm_plugin_t *plugin) +static int snd_pcm_plugin_insert(struct snd_pcm_plugin *plugin) { - snd_pcm_runtime_t *runtime = plugin->plug->runtime; + struct snd_pcm_runtime *runtime = plugin->plug->runtime; plugin->next = runtime->oss.plugin_first; plugin->prev = NULL; if (runtime->oss.plugin_first) { @@ -108,9 +108,9 @@ static int snd_pcm_plugin_insert(snd_pcm_plugin_t *plugin) return 0; } -int snd_pcm_plugin_append(snd_pcm_plugin_t *plugin) +int snd_pcm_plugin_append(struct snd_pcm_plugin *plugin) { - snd_pcm_runtime_t *runtime = plugin->plug->runtime; + struct snd_pcm_runtime *runtime = plugin->plug->runtime; plugin->next = NULL; plugin->prev = runtime->oss.plugin_last; if (runtime->oss.plugin_last) { @@ -123,9 +123,9 @@ int snd_pcm_plugin_append(snd_pcm_plugin_t *plugin) return 0; } -static long snd_pcm_oss_bytes(snd_pcm_substream_t *substream, long frames) +static long snd_pcm_oss_bytes(struct snd_pcm_substream *substream, long frames) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; long buffer_size = snd_pcm_lib_buffer_bytes(substream); long bytes = frames_to_bytes(runtime, frames); if (buffer_size == runtime->oss.buffer_bytes) @@ -142,9 +142,9 @@ static long snd_pcm_oss_bytes(snd_pcm_substream_t *substream, long frames) #endif } -static long snd_pcm_alsa_frames(snd_pcm_substream_t *substream, long bytes) +static long snd_pcm_alsa_frames(struct snd_pcm_substream *substream, long bytes) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; long buffer_size = snd_pcm_lib_buffer_bytes(substream); if (buffer_size == runtime->oss.buffer_bytes) return bytes_to_frames(runtime, bytes); @@ -185,14 +185,14 @@ static int snd_pcm_oss_format_to(int format) } } -static int snd_pcm_oss_period_size(snd_pcm_substream_t *substream, - snd_pcm_hw_params_t *oss_params, - snd_pcm_hw_params_t *slave_params) +static int snd_pcm_oss_period_size(struct snd_pcm_substream *substream, + struct snd_pcm_hw_params *oss_params, + struct snd_pcm_hw_params *slave_params) { size_t s; size_t oss_buffer_size, oss_period_size, oss_periods; size_t min_period_size, max_period_size; - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; size_t oss_frame_size; oss_frame_size = snd_pcm_format_physical_width(params_format(oss_params)) * @@ -277,11 +277,11 @@ static int snd_pcm_oss_period_size(snd_pcm_substream_t *substream, return 0; } -static int choose_rate(snd_pcm_substream_t *substream, - snd_pcm_hw_params_t *params, unsigned int best_rate) +static int choose_rate(struct snd_pcm_substream *substream, + struct snd_pcm_hw_params *params, unsigned int best_rate) { - snd_interval_t *it; - snd_pcm_hw_params_t *save; + struct snd_interval *it; + struct snd_pcm_hw_params *save; unsigned int rate, prev; save = kmalloc(sizeof(*save), GFP_KERNEL); @@ -317,18 +317,18 @@ static int choose_rate(snd_pcm_substream_t *substream, return snd_pcm_hw_param_near(substream, params, SNDRV_PCM_HW_PARAM_RATE, best_rate, NULL); } -static int snd_pcm_oss_change_params(snd_pcm_substream_t *substream) +static int snd_pcm_oss_change_params(struct snd_pcm_substream *substream) { - snd_pcm_runtime_t *runtime = substream->runtime; - snd_pcm_hw_params_t *params, *sparams; - snd_pcm_sw_params_t *sw_params; + struct snd_pcm_runtime *runtime = substream->runtime; + struct snd_pcm_hw_params *params, *sparams; + struct snd_pcm_sw_params *sw_params; ssize_t oss_buffer_size, oss_period_size; size_t oss_frame_size; int err; int direct; int format, sformat, n; - snd_mask_t sformat_mask; - snd_mask_t mask; + struct snd_mask sformat_mask; + struct snd_mask mask; sw_params = kmalloc(sizeof(*sw_params), GFP_KERNEL); params = kmalloc(sizeof(*params), GFP_KERNEL); @@ -342,7 +342,7 @@ static int snd_pcm_oss_change_params(snd_pcm_substream_t *substream) if (atomic_read(&runtime->mmap_count)) { direct = 1; } else { - snd_pcm_oss_setup_t *setup = substream->oss.setup; + struct snd_pcm_oss_setup *setup = substream->oss.setup; direct = (setup != NULL && setup->direct); } @@ -424,7 +424,7 @@ static int snd_pcm_oss_change_params(snd_pcm_substream_t *substream) goto failure; } if (runtime->oss.plugin_first) { - snd_pcm_plugin_t *plugin; + struct snd_pcm_plugin *plugin; if ((err = snd_pcm_plugin_build_io(substream, sparams, &plugin)) < 0) { snd_printd("snd_pcm_plugin_build_io failed: %i\n", err); snd_pcm_oss_plugin_clear(substream); @@ -540,10 +540,10 @@ failure: return err; } -static int snd_pcm_oss_get_active_substream(snd_pcm_oss_file_t *pcm_oss_file, snd_pcm_substream_t **r_substream) +static int snd_pcm_oss_get_active_substream(struct snd_pcm_oss_file *pcm_oss_file, struct snd_pcm_substream **r_substream) { int idx, err; - snd_pcm_substream_t *asubstream = NULL, *substream; + struct snd_pcm_substream *asubstream = NULL, *substream; for (idx = 0; idx < 2; idx++) { substream = pcm_oss_file->streams[idx]; @@ -563,10 +563,10 @@ static int snd_pcm_oss_get_active_substream(snd_pcm_oss_file_t *pcm_oss_file, sn return 0; } -static int snd_pcm_oss_prepare(snd_pcm_substream_t *substream) +static int snd_pcm_oss_prepare(struct snd_pcm_substream *substream) { int err; - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; err = snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_PREPARE, NULL); if (err < 0) { @@ -581,9 +581,9 @@ static int snd_pcm_oss_prepare(snd_pcm_substream_t *substream) return 0; } -static int snd_pcm_oss_make_ready(snd_pcm_substream_t *substream) +static int snd_pcm_oss_make_ready(struct snd_pcm_substream *substream) { - snd_pcm_runtime_t *runtime; + struct snd_pcm_runtime *runtime; int err; if (substream == NULL) @@ -602,9 +602,9 @@ static int snd_pcm_oss_make_ready(snd_pcm_substream_t *substream) return 0; } -static int snd_pcm_oss_capture_position_fixup(snd_pcm_substream_t *substream, snd_pcm_sframes_t *delay) +static int snd_pcm_oss_capture_position_fixup(struct snd_pcm_substream *substream, snd_pcm_sframes_t *delay) { - snd_pcm_runtime_t *runtime; + struct snd_pcm_runtime *runtime; snd_pcm_uframes_t frames; int err = 0; @@ -627,9 +627,9 @@ static int snd_pcm_oss_capture_position_fixup(snd_pcm_substream_t *substream, sn return err; } -snd_pcm_sframes_t snd_pcm_oss_write3(snd_pcm_substream_t *substream, const char *ptr, snd_pcm_uframes_t frames, int in_kernel) +snd_pcm_sframes_t snd_pcm_oss_write3(struct snd_pcm_substream *substream, const char *ptr, snd_pcm_uframes_t frames, int in_kernel) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; int ret; while (1) { if (runtime->status->state == SNDRV_PCM_STATE_XRUN || @@ -662,9 +662,9 @@ snd_pcm_sframes_t snd_pcm_oss_write3(snd_pcm_substream_t *substream, const char return ret; } -snd_pcm_sframes_t snd_pcm_oss_read3(snd_pcm_substream_t *substream, char *ptr, snd_pcm_uframes_t frames, int in_kernel) +snd_pcm_sframes_t snd_pcm_oss_read3(struct snd_pcm_substream *substream, char *ptr, snd_pcm_uframes_t frames, int in_kernel) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; snd_pcm_sframes_t delay; int ret; while (1) { @@ -709,9 +709,9 @@ snd_pcm_sframes_t snd_pcm_oss_read3(snd_pcm_substream_t *substream, char *ptr, s return ret; } -snd_pcm_sframes_t snd_pcm_oss_writev3(snd_pcm_substream_t *substream, void **bufs, snd_pcm_uframes_t frames, int in_kernel) +snd_pcm_sframes_t snd_pcm_oss_writev3(struct snd_pcm_substream *substream, void **bufs, snd_pcm_uframes_t frames, int in_kernel) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; int ret; while (1) { if (runtime->status->state == SNDRV_PCM_STATE_XRUN || @@ -745,9 +745,9 @@ snd_pcm_sframes_t snd_pcm_oss_writev3(snd_pcm_substream_t *substream, void **buf return ret; } -snd_pcm_sframes_t snd_pcm_oss_readv3(snd_pcm_substream_t *substream, void **bufs, snd_pcm_uframes_t frames, int in_kernel) +snd_pcm_sframes_t snd_pcm_oss_readv3(struct snd_pcm_substream *substream, void **bufs, snd_pcm_uframes_t frames, int in_kernel) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; int ret; while (1) { if (runtime->status->state == SNDRV_PCM_STATE_XRUN || @@ -780,12 +780,12 @@ snd_pcm_sframes_t snd_pcm_oss_readv3(snd_pcm_substream_t *substream, void **bufs return ret; } -static ssize_t snd_pcm_oss_write2(snd_pcm_substream_t *substream, const char *buf, size_t bytes, int in_kernel) +static ssize_t snd_pcm_oss_write2(struct snd_pcm_substream *substream, const char *buf, size_t bytes, int in_kernel) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; snd_pcm_sframes_t frames, frames1; if (runtime->oss.plugin_first) { - snd_pcm_plugin_channel_t *channels; + struct snd_pcm_plugin_channel *channels; size_t oss_frame_bytes = (runtime->oss.plugin_first->src_width * runtime->oss.plugin_first->src_format.channels) / 8; if (!in_kernel) { if (copy_from_user(runtime->oss.buffer, (const char __user *)buf, bytes)) @@ -810,11 +810,11 @@ static ssize_t snd_pcm_oss_write2(snd_pcm_substream_t *substream, const char *bu return bytes; } -static ssize_t snd_pcm_oss_write1(snd_pcm_substream_t *substream, const char __user *buf, size_t bytes) +static ssize_t snd_pcm_oss_write1(struct snd_pcm_substream *substream, const char __user *buf, size_t bytes) { size_t xfer = 0; ssize_t tmp; - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; if (atomic_read(&runtime->mmap_count)) return -ENXIO; @@ -867,13 +867,13 @@ static ssize_t snd_pcm_oss_write1(snd_pcm_substream_t *substream, const char __u return xfer; } -static ssize_t snd_pcm_oss_read2(snd_pcm_substream_t *substream, char *buf, size_t bytes, int in_kernel) +static ssize_t snd_pcm_oss_read2(struct snd_pcm_substream *substream, char *buf, size_t bytes, int in_kernel) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; snd_pcm_sframes_t frames, frames1; char __user *final_dst = (char __user *)buf; if (runtime->oss.plugin_first) { - snd_pcm_plugin_channel_t *channels; + struct snd_pcm_plugin_channel *channels; size_t oss_frame_bytes = (runtime->oss.plugin_last->dst_width * runtime->oss.plugin_last->dst_format.channels) / 8; if (!in_kernel) buf = runtime->oss.buffer; @@ -897,11 +897,11 @@ static ssize_t snd_pcm_oss_read2(snd_pcm_substream_t *substream, char *buf, size return bytes; } -static ssize_t snd_pcm_oss_read1(snd_pcm_substream_t *substream, char __user *buf, size_t bytes) +static ssize_t snd_pcm_oss_read1(struct snd_pcm_substream *substream, char __user *buf, size_t bytes) { size_t xfer = 0; ssize_t tmp; - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; if (atomic_read(&runtime->mmap_count)) return -ENXIO; @@ -941,9 +941,9 @@ static ssize_t snd_pcm_oss_read1(snd_pcm_substream_t *substream, char __user *bu return xfer; } -static int snd_pcm_oss_reset(snd_pcm_oss_file_t *pcm_oss_file) +static int snd_pcm_oss_reset(struct snd_pcm_oss_file *pcm_oss_file) { - snd_pcm_substream_t *substream; + struct snd_pcm_substream *substream; substream = pcm_oss_file->streams[SNDRV_PCM_STREAM_PLAYBACK]; if (substream != NULL) { @@ -958,9 +958,9 @@ static int snd_pcm_oss_reset(snd_pcm_oss_file_t *pcm_oss_file) return 0; } -static int snd_pcm_oss_post(snd_pcm_oss_file_t *pcm_oss_file) +static int snd_pcm_oss_post(struct snd_pcm_oss_file *pcm_oss_file) { - snd_pcm_substream_t *substream; + struct snd_pcm_substream *substream; int err; substream = pcm_oss_file->streams[SNDRV_PCM_STREAM_PLAYBACK]; @@ -974,9 +974,9 @@ static int snd_pcm_oss_post(snd_pcm_oss_file_t *pcm_oss_file) return 0; } -static int snd_pcm_oss_sync1(snd_pcm_substream_t *substream, size_t size) +static int snd_pcm_oss_sync1(struct snd_pcm_substream *substream, size_t size) { - snd_pcm_runtime_t *runtime; + struct snd_pcm_runtime *runtime; ssize_t result = 0; long res; wait_queue_t wait; @@ -1020,12 +1020,12 @@ static int snd_pcm_oss_sync1(snd_pcm_substream_t *substream, size_t size) return result; } -static int snd_pcm_oss_sync(snd_pcm_oss_file_t *pcm_oss_file) +static int snd_pcm_oss_sync(struct snd_pcm_oss_file *pcm_oss_file) { int err = 0; unsigned int saved_f_flags; - snd_pcm_substream_t *substream; - snd_pcm_runtime_t *runtime; + struct snd_pcm_substream *substream; + struct snd_pcm_runtime *runtime; snd_pcm_format_t format; unsigned long width; size_t size; @@ -1117,13 +1117,13 @@ static int snd_pcm_oss_sync(snd_pcm_oss_file_t *pcm_oss_file) return 0; } -static int snd_pcm_oss_set_rate(snd_pcm_oss_file_t *pcm_oss_file, int rate) +static int snd_pcm_oss_set_rate(struct snd_pcm_oss_file *pcm_oss_file, int rate) { int idx; for (idx = 1; idx >= 0; --idx) { - snd_pcm_substream_t *substream = pcm_oss_file->streams[idx]; - snd_pcm_runtime_t *runtime; + struct snd_pcm_substream *substream = pcm_oss_file->streams[idx]; + struct snd_pcm_runtime *runtime; if (substream == NULL) continue; runtime = substream->runtime; @@ -1139,9 +1139,9 @@ static int snd_pcm_oss_set_rate(snd_pcm_oss_file_t *pcm_oss_file, int rate) return snd_pcm_oss_get_rate(pcm_oss_file); } -static int snd_pcm_oss_get_rate(snd_pcm_oss_file_t *pcm_oss_file) +static int snd_pcm_oss_get_rate(struct snd_pcm_oss_file *pcm_oss_file) { - snd_pcm_substream_t *substream; + struct snd_pcm_substream *substream; int err; if ((err = snd_pcm_oss_get_active_substream(pcm_oss_file, &substream)) < 0) @@ -1149,7 +1149,7 @@ static int snd_pcm_oss_get_rate(snd_pcm_oss_file_t *pcm_oss_file) return substream->runtime->oss.rate; } -static int snd_pcm_oss_set_channels(snd_pcm_oss_file_t *pcm_oss_file, unsigned int channels) +static int snd_pcm_oss_set_channels(struct snd_pcm_oss_file *pcm_oss_file, unsigned int channels) { int idx; if (channels < 1) @@ -1157,8 +1157,8 @@ static int snd_pcm_oss_set_channels(snd_pcm_oss_file_t *pcm_oss_file, unsigned i if (channels > 128) return -EINVAL; for (idx = 1; idx >= 0; --idx) { - snd_pcm_substream_t *substream = pcm_oss_file->streams[idx]; - snd_pcm_runtime_t *runtime; + struct snd_pcm_substream *substream = pcm_oss_file->streams[idx]; + struct snd_pcm_runtime *runtime; if (substream == NULL) continue; runtime = substream->runtime; @@ -1170,9 +1170,9 @@ static int snd_pcm_oss_set_channels(snd_pcm_oss_file_t *pcm_oss_file, unsigned i return snd_pcm_oss_get_channels(pcm_oss_file); } -static int snd_pcm_oss_get_channels(snd_pcm_oss_file_t *pcm_oss_file) +static int snd_pcm_oss_get_channels(struct snd_pcm_oss_file *pcm_oss_file) { - snd_pcm_substream_t *substream; + struct snd_pcm_substream *substream; int err; if ((err = snd_pcm_oss_get_active_substream(pcm_oss_file, &substream)) < 0) @@ -1180,9 +1180,9 @@ static int snd_pcm_oss_get_channels(snd_pcm_oss_file_t *pcm_oss_file) return substream->runtime->oss.channels; } -static int snd_pcm_oss_get_block_size(snd_pcm_oss_file_t *pcm_oss_file) +static int snd_pcm_oss_get_block_size(struct snd_pcm_oss_file *pcm_oss_file) { - snd_pcm_substream_t *substream; + struct snd_pcm_substream *substream; int err; if ((err = snd_pcm_oss_get_active_substream(pcm_oss_file, &substream)) < 0) @@ -1190,14 +1190,14 @@ static int snd_pcm_oss_get_block_size(snd_pcm_oss_file_t *pcm_oss_file) return substream->runtime->oss.period_bytes; } -static int snd_pcm_oss_get_formats(snd_pcm_oss_file_t *pcm_oss_file) +static int snd_pcm_oss_get_formats(struct snd_pcm_oss_file *pcm_oss_file) { - snd_pcm_substream_t *substream; + struct snd_pcm_substream *substream; int err; int direct; - snd_pcm_hw_params_t *params; + struct snd_pcm_hw_params *params; unsigned int formats = 0; - snd_mask_t format_mask; + struct snd_mask format_mask; int fmt; if ((err = snd_pcm_oss_get_active_substream(pcm_oss_file, &substream)) < 0) @@ -1205,7 +1205,7 @@ static int snd_pcm_oss_get_formats(snd_pcm_oss_file_t *pcm_oss_file) if (atomic_read(&substream->runtime->mmap_count)) { direct = 1; } else { - snd_pcm_oss_setup_t *setup = substream->oss.setup; + struct snd_pcm_oss_setup *setup = substream->oss.setup; direct = (setup != NULL && setup->direct); } if (!direct) @@ -1231,7 +1231,7 @@ static int snd_pcm_oss_get_formats(snd_pcm_oss_file_t *pcm_oss_file) return formats; } -static int snd_pcm_oss_set_format(snd_pcm_oss_file_t *pcm_oss_file, int format) +static int snd_pcm_oss_set_format(struct snd_pcm_oss_file *pcm_oss_file, int format) { int formats, idx; @@ -1240,8 +1240,8 @@ static int snd_pcm_oss_set_format(snd_pcm_oss_file_t *pcm_oss_file, int format) if (!(formats & format)) format = AFMT_U8; for (idx = 1; idx >= 0; --idx) { - snd_pcm_substream_t *substream = pcm_oss_file->streams[idx]; - snd_pcm_runtime_t *runtime; + struct snd_pcm_substream *substream = pcm_oss_file->streams[idx]; + struct snd_pcm_runtime *runtime; if (substream == NULL) continue; runtime = substream->runtime; @@ -1254,9 +1254,9 @@ static int snd_pcm_oss_set_format(snd_pcm_oss_file_t *pcm_oss_file, int format) return snd_pcm_oss_get_format(pcm_oss_file); } -static int snd_pcm_oss_get_format(snd_pcm_oss_file_t *pcm_oss_file) +static int snd_pcm_oss_get_format(struct snd_pcm_oss_file *pcm_oss_file) { - snd_pcm_substream_t *substream; + struct snd_pcm_substream *substream; int err; if ((err = snd_pcm_oss_get_active_substream(pcm_oss_file, &substream)) < 0) @@ -1264,9 +1264,9 @@ static int snd_pcm_oss_get_format(snd_pcm_oss_file_t *pcm_oss_file) return substream->runtime->oss.format; } -static int snd_pcm_oss_set_subdivide1(snd_pcm_substream_t *substream, int subdivide) +static int snd_pcm_oss_set_subdivide1(struct snd_pcm_substream *substream, int subdivide) { - snd_pcm_runtime_t *runtime; + struct snd_pcm_runtime *runtime; if (substream == NULL) return 0; @@ -1287,12 +1287,12 @@ static int snd_pcm_oss_set_subdivide1(snd_pcm_substream_t *substream, int subdiv return subdivide; } -static int snd_pcm_oss_set_subdivide(snd_pcm_oss_file_t *pcm_oss_file, int subdivide) +static int snd_pcm_oss_set_subdivide(struct snd_pcm_oss_file *pcm_oss_file, int subdivide) { int err = -EINVAL, idx; for (idx = 1; idx >= 0; --idx) { - snd_pcm_substream_t *substream = pcm_oss_file->streams[idx]; + struct snd_pcm_substream *substream = pcm_oss_file->streams[idx]; if (substream == NULL) continue; if ((err = snd_pcm_oss_set_subdivide1(substream, subdivide)) < 0) @@ -1301,9 +1301,9 @@ static int snd_pcm_oss_set_subdivide(snd_pcm_oss_file_t *pcm_oss_file, int subdi return err; } -static int snd_pcm_oss_set_fragment1(snd_pcm_substream_t *substream, unsigned int val) +static int snd_pcm_oss_set_fragment1(struct snd_pcm_substream *substream, unsigned int val) { - snd_pcm_runtime_t *runtime; + struct snd_pcm_runtime *runtime; if (substream == NULL) return 0; @@ -1320,12 +1320,12 @@ static int snd_pcm_oss_set_fragment1(snd_pcm_substream_t *substream, unsigned in return 0; } -static int snd_pcm_oss_set_fragment(snd_pcm_oss_file_t *pcm_oss_file, unsigned int val) +static int snd_pcm_oss_set_fragment(struct snd_pcm_oss_file *pcm_oss_file, unsigned int val) { int err = -EINVAL, idx; for (idx = 1; idx >= 0; --idx) { - snd_pcm_substream_t *substream = pcm_oss_file->streams[idx]; + struct snd_pcm_substream *substream = pcm_oss_file->streams[idx]; if (substream == NULL) continue; if ((err = snd_pcm_oss_set_fragment1(substream, val)) < 0) @@ -1340,7 +1340,7 @@ static int snd_pcm_oss_nonblock(struct file * file) return 0; } -static int snd_pcm_oss_get_caps1(snd_pcm_substream_t *substream, int res) +static int snd_pcm_oss_get_caps1(struct snd_pcm_substream *substream, int res) { if (substream == NULL) { @@ -1356,7 +1356,7 @@ static int snd_pcm_oss_get_caps1(snd_pcm_substream_t *substream, int res) /* all ALSA drivers can return actual pointer in ring buffer */ #if defined(DSP_CAP_REALTIME) && 0 { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; if (runtime->info & (SNDRV_PCM_INFO_BLOCK_TRANSFER|SNDRV_PCM_INFO_BATCH)) res &= ~DSP_CAP_REALTIME; } @@ -1364,32 +1364,32 @@ static int snd_pcm_oss_get_caps1(snd_pcm_substream_t *substream, int res) return res; } -static int snd_pcm_oss_get_caps(snd_pcm_oss_file_t *pcm_oss_file) +static int snd_pcm_oss_get_caps(struct snd_pcm_oss_file *pcm_oss_file) { int result, idx; result = DSP_CAP_TRIGGER | DSP_CAP_MMAP | DSP_CAP_DUPLEX | DSP_CAP_REALTIME; for (idx = 0; idx < 2; idx++) { - snd_pcm_substream_t *substream = pcm_oss_file->streams[idx]; + struct snd_pcm_substream *substream = pcm_oss_file->streams[idx]; result = snd_pcm_oss_get_caps1(substream, result); } result |= 0x0001; /* revision - same as SB AWE 64 */ return result; } -static void snd_pcm_oss_simulate_fill(snd_pcm_substream_t *substream, snd_pcm_uframes_t hw_ptr) +static void snd_pcm_oss_simulate_fill(struct snd_pcm_substream *substream, snd_pcm_uframes_t hw_ptr) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; snd_pcm_uframes_t appl_ptr; appl_ptr = hw_ptr + runtime->buffer_size; appl_ptr %= runtime->boundary; runtime->control->appl_ptr = appl_ptr; } -static int snd_pcm_oss_set_trigger(snd_pcm_oss_file_t *pcm_oss_file, int trigger) +static int snd_pcm_oss_set_trigger(struct snd_pcm_oss_file *pcm_oss_file, int trigger) { - snd_pcm_runtime_t *runtime; - snd_pcm_substream_t *psubstream = NULL, *csubstream = NULL; + struct snd_pcm_runtime *runtime; + struct snd_pcm_substream *psubstream = NULL, *csubstream = NULL; int err, cmd; #ifdef OSS_DEBUG @@ -1454,9 +1454,9 @@ static int snd_pcm_oss_set_trigger(snd_pcm_oss_file_t *pcm_oss_file, int trigger return 0; } -static int snd_pcm_oss_get_trigger(snd_pcm_oss_file_t *pcm_oss_file) +static int snd_pcm_oss_get_trigger(struct snd_pcm_oss_file *pcm_oss_file) { - snd_pcm_substream_t *psubstream = NULL, *csubstream = NULL; + struct snd_pcm_substream *psubstream = NULL, *csubstream = NULL; int result = 0; psubstream = pcm_oss_file->streams[SNDRV_PCM_STREAM_PLAYBACK]; @@ -1468,10 +1468,10 @@ static int snd_pcm_oss_get_trigger(snd_pcm_oss_file_t *pcm_oss_file) return result; } -static int snd_pcm_oss_get_odelay(snd_pcm_oss_file_t *pcm_oss_file) +static int snd_pcm_oss_get_odelay(struct snd_pcm_oss_file *pcm_oss_file) { - snd_pcm_substream_t *substream; - snd_pcm_runtime_t *runtime; + struct snd_pcm_substream *substream; + struct snd_pcm_runtime *runtime; snd_pcm_sframes_t delay; int err; @@ -1491,10 +1491,10 @@ static int snd_pcm_oss_get_odelay(snd_pcm_oss_file_t *pcm_oss_file) return snd_pcm_oss_bytes(substream, delay); } -static int snd_pcm_oss_get_ptr(snd_pcm_oss_file_t *pcm_oss_file, int stream, struct count_info __user * _info) +static int snd_pcm_oss_get_ptr(struct snd_pcm_oss_file *pcm_oss_file, int stream, struct count_info __user * _info) { - snd_pcm_substream_t *substream; - snd_pcm_runtime_t *runtime; + struct snd_pcm_substream *substream; + struct snd_pcm_runtime *runtime; snd_pcm_sframes_t delay; int fixup; struct count_info info; @@ -1543,7 +1543,7 @@ static int snd_pcm_oss_get_ptr(snd_pcm_oss_file_t *pcm_oss_file, int stream, str } else { delay = snd_pcm_oss_bytes(substream, delay); if (stream == SNDRV_PCM_STREAM_PLAYBACK) { - snd_pcm_oss_setup_t *setup = substream->oss.setup; + struct snd_pcm_oss_setup *setup = substream->oss.setup; if (setup && setup->buggyptr) info.blocks = (runtime->oss.buffer_bytes - delay - fixup) / runtime->oss.period_bytes; else @@ -1560,10 +1560,10 @@ static int snd_pcm_oss_get_ptr(snd_pcm_oss_file_t *pcm_oss_file, int stream, str return 0; } -static int snd_pcm_oss_get_space(snd_pcm_oss_file_t *pcm_oss_file, int stream, struct audio_buf_info __user *_info) +static int snd_pcm_oss_get_space(struct snd_pcm_oss_file *pcm_oss_file, int stream, struct audio_buf_info __user *_info) { - snd_pcm_substream_t *substream; - snd_pcm_runtime_t *runtime; + struct snd_pcm_substream *substream; + struct snd_pcm_runtime *runtime; snd_pcm_sframes_t avail; int fixup; struct audio_buf_info info; @@ -1619,17 +1619,17 @@ static int snd_pcm_oss_get_space(snd_pcm_oss_file_t *pcm_oss_file, int stream, s return 0; } -static int snd_pcm_oss_get_mapbuf(snd_pcm_oss_file_t *pcm_oss_file, int stream, struct buffmem_desc __user * _info) +static int snd_pcm_oss_get_mapbuf(struct snd_pcm_oss_file *pcm_oss_file, int stream, struct buffmem_desc __user * _info) { // it won't be probably implemented // snd_printd("TODO: snd_pcm_oss_get_mapbuf\n"); return -EINVAL; } -static snd_pcm_oss_setup_t *snd_pcm_oss_look_for_setup(snd_pcm_t *pcm, int stream, const char *task_name) +static struct snd_pcm_oss_setup *snd_pcm_oss_look_for_setup(struct snd_pcm *pcm, int stream, const char *task_name) { const char *ptr, *ptrl; - snd_pcm_oss_setup_t *setup; + struct snd_pcm_oss_setup *setup; down(&pcm->streams[stream].oss.setup_mutex); for (setup = pcm->streams[stream].oss.setup_list; setup; setup = setup->next) { @@ -1659,11 +1659,11 @@ static snd_pcm_oss_setup_t *snd_pcm_oss_look_for_setup(snd_pcm_t *pcm, int strea return NULL; } -static void snd_pcm_oss_init_substream(snd_pcm_substream_t *substream, - snd_pcm_oss_setup_t *setup, +static void snd_pcm_oss_init_substream(struct snd_pcm_substream *substream, + struct snd_pcm_oss_setup *setup, int minor) { - snd_pcm_runtime_t *runtime; + struct snd_pcm_runtime *runtime; substream->oss.oss = 1; substream->oss.setup = setup; @@ -1687,9 +1687,9 @@ static void snd_pcm_oss_init_substream(snd_pcm_substream_t *substream, runtime->oss.subdivision = 0; } -static void snd_pcm_oss_release_substream(snd_pcm_substream_t *substream) +static void snd_pcm_oss_release_substream(struct snd_pcm_substream *substream) { - snd_pcm_runtime_t *runtime; + struct snd_pcm_runtime *runtime; runtime = substream->runtime; vfree(runtime->oss.buffer); snd_pcm_oss_plugin_clear(substream); @@ -1697,13 +1697,13 @@ static void snd_pcm_oss_release_substream(snd_pcm_substream_t *substream) substream->oss.oss = 0; } -static int snd_pcm_oss_release_file(snd_pcm_oss_file_t *pcm_oss_file) +static int snd_pcm_oss_release_file(struct snd_pcm_oss_file *pcm_oss_file) { int cidx; snd_assert(pcm_oss_file != NULL, return -ENXIO); for (cidx = 0; cidx < 2; ++cidx) { - snd_pcm_substream_t *substream = pcm_oss_file->streams[cidx]; - snd_pcm_runtime_t *runtime; + struct snd_pcm_substream *substream = pcm_oss_file->streams[cidx]; + struct snd_pcm_runtime *runtime; if (substream == NULL) continue; runtime = substream->runtime; @@ -1726,15 +1726,15 @@ static int snd_pcm_oss_release_file(snd_pcm_oss_file_t *pcm_oss_file) } static int snd_pcm_oss_open_file(struct file *file, - snd_pcm_t *pcm, - snd_pcm_oss_file_t **rpcm_oss_file, + struct snd_pcm *pcm, + struct snd_pcm_oss_file **rpcm_oss_file, int minor, - snd_pcm_oss_setup_t *psetup, - snd_pcm_oss_setup_t *csetup) + struct snd_pcm_oss_setup *psetup, + struct snd_pcm_oss_setup *csetup) { int err = 0; - snd_pcm_oss_file_t *pcm_oss_file; - snd_pcm_substream_t *psubstream = NULL, *csubstream = NULL; + struct snd_pcm_oss_file *pcm_oss_file; + struct snd_pcm_substream *psubstream = NULL, *csubstream = NULL; unsigned int f_mode = file->f_mode; snd_assert(rpcm_oss_file != NULL, return -EINVAL); @@ -1834,22 +1834,16 @@ 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]; - snd_pcm_t *pcm; - snd_pcm_oss_file_t *pcm_oss_file; - snd_pcm_oss_setup_t *psetup = NULL, *csetup = NULL; + struct snd_pcm *pcm; + struct snd_pcm_oss_file *pcm_oss_file; + struct snd_pcm_oss_setup *psetup = NULL, *csetup = NULL; 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) { @@ -1925,9 +1919,9 @@ static int snd_pcm_oss_open(struct inode *inode, struct file *file) static int snd_pcm_oss_release(struct inode *inode, struct file *file) { - snd_pcm_t *pcm; - snd_pcm_substream_t *substream; - snd_pcm_oss_file_t *pcm_oss_file; + struct snd_pcm *pcm; + struct snd_pcm_substream *substream; + struct snd_pcm_oss_file *pcm_oss_file; pcm_oss_file = file->private_data; substream = pcm_oss_file->streams[SNDRV_PCM_STREAM_PLAYBACK]; @@ -1947,7 +1941,7 @@ static int snd_pcm_oss_release(struct inode *inode, struct file *file) static long snd_pcm_oss_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { - snd_pcm_oss_file_t *pcm_oss_file; + struct snd_pcm_oss_file *pcm_oss_file; int __user *p = (int __user *)arg; int res; @@ -1958,7 +1952,7 @@ static long snd_pcm_oss_ioctl(struct file *file, unsigned int cmd, unsigned long return put_user(1, p); #if defined(CONFIG_SND_MIXER_OSS) || (defined(MODULE) && defined(CONFIG_SND_MIXER_OSS_MODULE)) if (((cmd >> 8) & 0xff) == 'M') { /* mixer ioctl - for OSS compatibility */ - snd_pcm_substream_t *substream; + struct snd_pcm_substream *substream; int idx; for (idx = 0; idx < 2; ++idx) { substream = pcm_oss_file->streams[idx]; @@ -2113,8 +2107,8 @@ static long snd_pcm_oss_ioctl(struct file *file, unsigned int cmd, unsigned long static ssize_t snd_pcm_oss_read(struct file *file, char __user *buf, size_t count, loff_t *offset) { - snd_pcm_oss_file_t *pcm_oss_file; - snd_pcm_substream_t *substream; + struct snd_pcm_oss_file *pcm_oss_file; + struct snd_pcm_substream *substream; pcm_oss_file = file->private_data; substream = pcm_oss_file->streams[SNDRV_PCM_STREAM_CAPTURE]; @@ -2133,35 +2127,33 @@ static ssize_t snd_pcm_oss_read(struct file *file, char __user *buf, size_t coun static ssize_t snd_pcm_oss_write(struct file *file, const char __user *buf, size_t count, loff_t *offset) { - snd_pcm_oss_file_t *pcm_oss_file; - snd_pcm_substream_t *substream; + struct snd_pcm_oss_file *pcm_oss_file; + struct snd_pcm_substream *substream; long result; pcm_oss_file = file->private_data; substream = pcm_oss_file->streams[SNDRV_PCM_STREAM_PLAYBACK]; if (substream == NULL) return -ENXIO; - up(&file->f_dentry->d_inode->i_sem); result = snd_pcm_oss_write1(substream, buf, count); - down(&file->f_dentry->d_inode->i_sem); #ifdef OSS_DEBUG printk("pcm_oss: write %li bytes (wrote %li bytes)\n", (long)count, (long)result); #endif return result; } -static int snd_pcm_oss_playback_ready(snd_pcm_substream_t *substream) +static int snd_pcm_oss_playback_ready(struct snd_pcm_substream *substream) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; if (atomic_read(&runtime->mmap_count)) return runtime->oss.prev_hw_ptr_interrupt != runtime->hw_ptr_interrupt; else return snd_pcm_playback_avail(runtime) >= runtime->oss.period_frames; } -static int snd_pcm_oss_capture_ready(snd_pcm_substream_t *substream) +static int snd_pcm_oss_capture_ready(struct snd_pcm_substream *substream) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; if (atomic_read(&runtime->mmap_count)) return runtime->oss.prev_hw_ptr_interrupt != runtime->hw_ptr_interrupt; else @@ -2170,9 +2162,9 @@ static int snd_pcm_oss_capture_ready(snd_pcm_substream_t *substream) static unsigned int snd_pcm_oss_poll(struct file *file, poll_table * wait) { - snd_pcm_oss_file_t *pcm_oss_file; + struct snd_pcm_oss_file *pcm_oss_file; unsigned int mask; - snd_pcm_substream_t *psubstream = NULL, *csubstream = NULL; + struct snd_pcm_substream *psubstream = NULL, *csubstream = NULL; pcm_oss_file = file->private_data; @@ -2181,7 +2173,7 @@ static unsigned int snd_pcm_oss_poll(struct file *file, poll_table * wait) mask = 0; if (psubstream != NULL) { - snd_pcm_runtime_t *runtime = psubstream->runtime; + struct snd_pcm_runtime *runtime = psubstream->runtime; poll_wait(file, &runtime->sleep, wait); snd_pcm_stream_lock_irq(psubstream); if (runtime->status->state != SNDRV_PCM_STATE_DRAINING && @@ -2191,8 +2183,8 @@ static unsigned int snd_pcm_oss_poll(struct file *file, poll_table * wait) snd_pcm_stream_unlock_irq(psubstream); } if (csubstream != NULL) { - snd_pcm_runtime_t *runtime = csubstream->runtime; - enum sndrv_pcm_state ostate; + struct snd_pcm_runtime *runtime = csubstream->runtime; + snd_pcm_state_t ostate; poll_wait(file, &runtime->sleep, wait); snd_pcm_stream_lock_irq(csubstream); if ((ostate = runtime->status->state) != SNDRV_PCM_STATE_RUNNING || @@ -2200,7 +2192,7 @@ static unsigned int snd_pcm_oss_poll(struct file *file, poll_table * wait) mask |= POLLIN | POLLRDNORM; snd_pcm_stream_unlock_irq(csubstream); if (ostate != SNDRV_PCM_STATE_RUNNING && runtime->oss.trigger) { - snd_pcm_oss_file_t ofile; + struct snd_pcm_oss_file ofile; memset(&ofile, 0, sizeof(ofile)); ofile.streams[SNDRV_PCM_STREAM_CAPTURE] = pcm_oss_file->streams[SNDRV_PCM_STREAM_CAPTURE]; runtime->oss.trigger = 0; @@ -2213,9 +2205,9 @@ static unsigned int snd_pcm_oss_poll(struct file *file, poll_table * wait) static int snd_pcm_oss_mmap(struct file *file, struct vm_area_struct *area) { - snd_pcm_oss_file_t *pcm_oss_file; - snd_pcm_substream_t *substream = NULL; - snd_pcm_runtime_t *runtime; + struct snd_pcm_oss_file *pcm_oss_file; + struct snd_pcm_substream *substream = NULL; + struct snd_pcm_runtime *runtime; int err; #ifdef OSS_DEBUG @@ -2275,15 +2267,16 @@ static int snd_pcm_oss_mmap(struct file *file, struct vm_area_struct *area) return 0; } +#ifdef CONFIG_PROC_FS /* * /proc interface */ -static void snd_pcm_oss_proc_read(snd_info_entry_t *entry, - snd_info_buffer_t * buffer) +static void snd_pcm_oss_proc_read(struct snd_info_entry *entry, + struct snd_info_buffer *buffer) { - snd_pcm_str_t *pstr = (snd_pcm_str_t *)entry->private_data; - snd_pcm_oss_setup_t *setup = pstr->oss.setup_list; + struct snd_pcm_str *pstr = entry->private_data; + struct snd_pcm_oss_setup *setup = pstr->oss.setup_list; down(&pstr->oss.setup_mutex); while (setup) { snd_iprintf(buffer, "%s %u %u%s%s%s%s%s%s\n", @@ -2301,11 +2294,11 @@ static void snd_pcm_oss_proc_read(snd_info_entry_t *entry, up(&pstr->oss.setup_mutex); } -static void snd_pcm_oss_proc_free_setup_list(snd_pcm_str_t * pstr) +static void snd_pcm_oss_proc_free_setup_list(struct snd_pcm_str * pstr) { unsigned int idx; - snd_pcm_substream_t *substream; - snd_pcm_oss_setup_t *setup, *setupn; + struct snd_pcm_substream *substream; + struct snd_pcm_oss_setup *setup, *setupn; for (idx = 0, substream = pstr->substream; idx < pstr->substream_count; idx++, substream = substream->next) @@ -2319,13 +2312,13 @@ static void snd_pcm_oss_proc_free_setup_list(snd_pcm_str_t * pstr) pstr->oss.setup_list = NULL; } -static void snd_pcm_oss_proc_write(snd_info_entry_t *entry, - snd_info_buffer_t * buffer) +static void snd_pcm_oss_proc_write(struct snd_info_entry *entry, + struct snd_info_buffer *buffer) { - snd_pcm_str_t *pstr = (snd_pcm_str_t *)entry->private_data; + struct snd_pcm_str *pstr = entry->private_data; char line[128], str[32], task_name[32], *ptr; int idx1; - snd_pcm_oss_setup_t *setup, *setup1, template; + struct snd_pcm_oss_setup *setup, *setup1, template; while (!snd_info_get_line(buffer, line, sizeof(line))) { down(&pstr->oss.setup_mutex); @@ -2370,7 +2363,7 @@ static void snd_pcm_oss_proc_write(snd_info_entry_t *entry, } } while (*str); if (setup == NULL) { - setup = (snd_pcm_oss_setup_t *) kmalloc(sizeof(snd_pcm_oss_setup_t), GFP_KERNEL); + setup = kmalloc(sizeof(struct snd_pcm_oss_setup), GFP_KERNEL); if (setup) { if (pstr->oss.setup_list == NULL) { pstr->oss.setup_list = setup; @@ -2389,12 +2382,12 @@ static void snd_pcm_oss_proc_write(snd_info_entry_t *entry, } } -static void snd_pcm_oss_proc_init(snd_pcm_t *pcm) +static void snd_pcm_oss_proc_init(struct snd_pcm *pcm) { int stream; for (stream = 0; stream < 2; ++stream) { - snd_info_entry_t *entry; - snd_pcm_str_t *pstr = &pcm->streams[stream]; + struct snd_info_entry *entry; + struct snd_pcm_str *pstr = &pcm->streams[stream]; if (pstr->substream_count == 0) continue; if ((entry = snd_info_create_card_entry(pcm->card, "oss", pstr->proc_root)) != NULL) { @@ -2414,11 +2407,11 @@ static void snd_pcm_oss_proc_init(snd_pcm_t *pcm) } } -static void snd_pcm_oss_proc_done(snd_pcm_t *pcm) +static void snd_pcm_oss_proc_done(struct snd_pcm *pcm) { int stream; for (stream = 0; stream < 2; ++stream) { - snd_pcm_str_t *pstr = &pcm->streams[stream]; + struct snd_pcm_str *pstr = &pcm->streams[stream]; if (pstr->oss.proc_entry) { snd_info_unregister(pstr->oss.proc_entry); pstr->oss.proc_entry = NULL; @@ -2426,6 +2419,10 @@ static void snd_pcm_oss_proc_done(snd_pcm_t *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 @@ -2444,25 +2441,19 @@ static struct file_operations snd_pcm_oss_f_reg = .mmap = snd_pcm_oss_mmap, }; -static snd_minor_t snd_pcm_oss_reg = -{ - .comment = "digital audio", - .f_ops = &snd_pcm_oss_f_reg, -}; - -static void register_oss_dsp(snd_pcm_t *pcm, int index) +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, - name) < 0) { + pcm->card, index, &snd_pcm_oss_f_reg, + pcm, name) < 0) { snd_printk(KERN_ERR "unable to register OSS PCM device %i:%i\n", pcm->card->number, pcm->device); } } -static int snd_pcm_oss_register_minor(snd_pcm_t * pcm) +static int snd_pcm_oss_register_minor(struct snd_pcm *pcm) { pcm->oss.reg = 0; if (dsp_map[pcm->card->number] == (int)pcm->device) { @@ -2493,7 +2484,7 @@ static int snd_pcm_oss_register_minor(snd_pcm_t * pcm) return 0; } -static int snd_pcm_oss_disconnect_minor(snd_pcm_t * pcm) +static int snd_pcm_oss_disconnect_minor(struct snd_pcm *pcm) { if (pcm->oss.reg) { if (pcm->oss.reg_mask & 1) { @@ -2510,7 +2501,7 @@ static int snd_pcm_oss_disconnect_minor(snd_pcm_t * pcm) return 0; } -static int snd_pcm_oss_unregister_minor(snd_pcm_t * pcm) +static int snd_pcm_oss_unregister_minor(struct snd_pcm *pcm) { snd_pcm_oss_disconnect_minor(pcm); if (pcm->oss.reg) { @@ -2525,7 +2516,7 @@ static int snd_pcm_oss_unregister_minor(snd_pcm_t * pcm) return 0; } -static snd_pcm_notify_t snd_pcm_oss_notify = +static struct snd_pcm_notify snd_pcm_oss_notify = { .n_register = snd_pcm_oss_register_minor, .n_disconnect = snd_pcm_oss_disconnect_minor, diff --git a/sound/core/oss/pcm_plugin.c b/sound/core/oss/pcm_plugin.c index fc23373c000..7e8676880dd 100644 --- a/sound/core/oss/pcm_plugin.c +++ b/sound/core/oss/pcm_plugin.c @@ -36,22 +36,22 @@ #define snd_pcm_plug_first(plug) ((plug)->runtime->oss.plugin_first) #define snd_pcm_plug_last(plug) ((plug)->runtime->oss.plugin_last) -static int snd_pcm_plugin_src_channels_mask(snd_pcm_plugin_t *plugin, - bitset_t *dst_vmask, - bitset_t **src_vmask) +static int snd_pcm_plugin_src_channels_mask(struct snd_pcm_plugin *plugin, + unsigned long *dst_vmask, + unsigned long **src_vmask) { - bitset_t *vmask = plugin->src_vmask; - bitset_copy(vmask, dst_vmask, plugin->src_format.channels); + unsigned long *vmask = plugin->src_vmask; + bitmap_copy(vmask, dst_vmask, plugin->src_format.channels); *src_vmask = vmask; return 0; } -static int snd_pcm_plugin_dst_channels_mask(snd_pcm_plugin_t *plugin, - bitset_t *src_vmask, - bitset_t **dst_vmask) +static int snd_pcm_plugin_dst_channels_mask(struct snd_pcm_plugin *plugin, + unsigned long *src_vmask, + unsigned long **dst_vmask) { - bitset_t *vmask = plugin->dst_vmask; - bitset_copy(vmask, src_vmask, plugin->dst_format.channels); + unsigned long *vmask = plugin->dst_vmask; + bitmap_copy(vmask, src_vmask, plugin->dst_format.channels); *dst_vmask = vmask; return 0; } @@ -67,13 +67,13 @@ static int rate_match(unsigned int src_rate, unsigned int dst_rate) return dst_rate >= low && dst_rate <= high; } -static int snd_pcm_plugin_alloc(snd_pcm_plugin_t *plugin, snd_pcm_uframes_t frames) +static int snd_pcm_plugin_alloc(struct snd_pcm_plugin *plugin, snd_pcm_uframes_t frames) { - snd_pcm_plugin_format_t *format; + struct snd_pcm_plugin_format *format; ssize_t width; size_t size; unsigned int channel; - snd_pcm_plugin_channel_t *c; + struct snd_pcm_plugin_channel *c; if (plugin->stream == SNDRV_PCM_STREAM_PLAYBACK) { format = &plugin->src_format; @@ -120,12 +120,12 @@ static int snd_pcm_plugin_alloc(snd_pcm_plugin_t *plugin, snd_pcm_uframes_t fram return 0; } -int snd_pcm_plug_alloc(snd_pcm_plug_t *plug, snd_pcm_uframes_t frames) +int snd_pcm_plug_alloc(struct snd_pcm_substream *plug, snd_pcm_uframes_t frames) { int err; snd_assert(snd_pcm_plug_first(plug) != NULL, return -ENXIO); if (snd_pcm_plug_stream(plug) == SNDRV_PCM_STREAM_PLAYBACK) { - snd_pcm_plugin_t *plugin = snd_pcm_plug_first(plug); + struct snd_pcm_plugin *plugin = snd_pcm_plug_first(plug); while (plugin->next) { if (plugin->dst_frames) frames = plugin->dst_frames(plugin, frames); @@ -136,7 +136,7 @@ int snd_pcm_plug_alloc(snd_pcm_plug_t *plug, snd_pcm_uframes_t frames) return err; } } else { - snd_pcm_plugin_t *plugin = snd_pcm_plug_last(plug); + struct snd_pcm_plugin *plugin = snd_pcm_plug_last(plug); while (plugin->prev) { if (plugin->src_frames) frames = plugin->src_frames(plugin, frames); @@ -151,22 +151,22 @@ int snd_pcm_plug_alloc(snd_pcm_plug_t *plug, snd_pcm_uframes_t frames) } -snd_pcm_sframes_t snd_pcm_plugin_client_channels(snd_pcm_plugin_t *plugin, +snd_pcm_sframes_t snd_pcm_plugin_client_channels(struct snd_pcm_plugin *plugin, snd_pcm_uframes_t frames, - snd_pcm_plugin_channel_t **channels) + struct snd_pcm_plugin_channel **channels) { *channels = plugin->buf_channels; return frames; } -int snd_pcm_plugin_build(snd_pcm_plug_t *plug, +int snd_pcm_plugin_build(struct snd_pcm_substream *plug, const char *name, - snd_pcm_plugin_format_t *src_format, - snd_pcm_plugin_format_t *dst_format, + struct snd_pcm_plugin_format *src_format, + struct snd_pcm_plugin_format *dst_format, size_t extra, - snd_pcm_plugin_t **ret) + struct snd_pcm_plugin **ret) { - snd_pcm_plugin_t *plugin; + struct snd_pcm_plugin *plugin; unsigned int channels; snd_assert(plug != NULL, return -ENXIO); @@ -193,12 +193,12 @@ int snd_pcm_plugin_build(snd_pcm_plug_t *plug, snd_pcm_plugin_free(plugin); return -ENOMEM; } - plugin->src_vmask = bitset_alloc(src_format->channels); + plugin->src_vmask = bitmap_alloc(src_format->channels); if (plugin->src_vmask == NULL) { snd_pcm_plugin_free(plugin); return -ENOMEM; } - plugin->dst_vmask = bitset_alloc(dst_format->channels); + plugin->dst_vmask = bitmap_alloc(dst_format->channels); if (plugin->dst_vmask == NULL) { snd_pcm_plugin_free(plugin); return -ENOMEM; @@ -210,7 +210,7 @@ int snd_pcm_plugin_build(snd_pcm_plug_t *plug, return 0; } -int snd_pcm_plugin_free(snd_pcm_plugin_t *plugin) +int snd_pcm_plugin_free(struct snd_pcm_plugin *plugin) { if (! plugin) return 0; @@ -224,9 +224,9 @@ int snd_pcm_plugin_free(snd_pcm_plugin_t *plugin) return 0; } -snd_pcm_sframes_t snd_pcm_plug_client_size(snd_pcm_plug_t *plug, snd_pcm_uframes_t drv_frames) +snd_pcm_sframes_t snd_pcm_plug_client_size(struct snd_pcm_substream *plug, snd_pcm_uframes_t drv_frames) { - snd_pcm_plugin_t *plugin, *plugin_prev, *plugin_next; + struct snd_pcm_plugin *plugin, *plugin_prev, *plugin_next; int stream = snd_pcm_plug_stream(plug); snd_assert(plug != NULL, return -ENXIO); @@ -253,9 +253,9 @@ snd_pcm_sframes_t snd_pcm_plug_client_size(snd_pcm_plug_t *plug, snd_pcm_uframes return drv_frames; } -snd_pcm_sframes_t snd_pcm_plug_slave_size(snd_pcm_plug_t *plug, snd_pcm_uframes_t clt_frames) +snd_pcm_sframes_t snd_pcm_plug_slave_size(struct snd_pcm_substream *plug, snd_pcm_uframes_t clt_frames) { - snd_pcm_plugin_t *plugin, *plugin_prev, *plugin_next; + struct snd_pcm_plugin *plugin, *plugin_prev, *plugin_next; snd_pcm_sframes_t frames; int stream = snd_pcm_plug_stream(plug); @@ -290,9 +290,9 @@ snd_pcm_sframes_t snd_pcm_plug_slave_size(snd_pcm_plug_t *plug, snd_pcm_uframes_ return frames; } -static int snd_pcm_plug_formats(snd_mask_t *mask, int format) +static int snd_pcm_plug_formats(struct snd_mask *mask, int format) { - snd_mask_t formats = *mask; + struct snd_mask formats = *mask; u64 linfmts = (SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_U16_LE | SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_U16_BE | SNDRV_PCM_FMTBIT_S16_BE | @@ -326,7 +326,7 @@ static int preferred_formats[] = { SNDRV_PCM_FORMAT_U8 }; -int snd_pcm_plug_slave_format(int format, snd_mask_t *format_mask) +int snd_pcm_plug_slave_format(int format, struct snd_mask *format_mask) { if (snd_mask_test(format_mask, format)) return format; @@ -376,15 +376,15 @@ int snd_pcm_plug_slave_format(int format, snd_mask_t *format_mask) } } -int snd_pcm_plug_format_plugins(snd_pcm_plug_t *plug, - snd_pcm_hw_params_t *params, - snd_pcm_hw_params_t *slave_params) +int snd_pcm_plug_format_plugins(struct snd_pcm_substream *plug, + struct snd_pcm_hw_params *params, + struct snd_pcm_hw_params *slave_params) { - snd_pcm_plugin_format_t tmpformat; - snd_pcm_plugin_format_t dstformat; - snd_pcm_plugin_format_t srcformat; + struct snd_pcm_plugin_format tmpformat; + struct snd_pcm_plugin_format dstformat; + struct snd_pcm_plugin_format srcformat; int src_access, dst_access; - snd_pcm_plugin_t *plugin = NULL; + struct snd_pcm_plugin *plugin = NULL; int err; int stream = snd_pcm_plug_stream(plug); int slave_interleaved = (params_channels(slave_params) == 1 || @@ -462,7 +462,7 @@ int snd_pcm_plug_format_plugins(snd_pcm_plug_t *plug, if (srcformat.channels > dstformat.channels) { int sv = srcformat.channels; int dv = dstformat.channels; - route_ttable_entry_t *ttable = kcalloc(dv * sv, sizeof(*ttable), GFP_KERNEL); + int *ttable = kcalloc(dv * sv, sizeof(*ttable), GFP_KERNEL); if (ttable == NULL) return -ENOMEM; #if 1 @@ -525,7 +525,7 @@ int snd_pcm_plug_format_plugins(snd_pcm_plug_t *plug, if (srcformat.channels < dstformat.channels) { int sv = srcformat.channels; int dv = dstformat.channels; - route_ttable_entry_t *ttable = kcalloc(dv * sv, sizeof(*ttable), GFP_KERNEL); + int *ttable = kcalloc(dv * sv, sizeof(*ttable), GFP_KERNEL); if (ttable == NULL) return -ENOMEM; #if 0 @@ -614,14 +614,14 @@ int snd_pcm_plug_format_plugins(snd_pcm_plug_t *plug, return 0; } -snd_pcm_sframes_t snd_pcm_plug_client_channels_buf(snd_pcm_plug_t *plug, +snd_pcm_sframes_t snd_pcm_plug_client_channels_buf(struct snd_pcm_substream *plug, char *buf, snd_pcm_uframes_t count, - snd_pcm_plugin_channel_t **channels) + struct snd_pcm_plugin_channel **channels) { - snd_pcm_plugin_t *plugin; - snd_pcm_plugin_channel_t *v; - snd_pcm_plugin_format_t *format; + struct snd_pcm_plugin *plugin; + struct snd_pcm_plugin_channel *v; + struct snd_pcm_plugin_format *format; int width, nchannels, channel; int stream = snd_pcm_plug_stream(plug); @@ -650,19 +650,19 @@ snd_pcm_sframes_t snd_pcm_plug_client_channels_buf(snd_pcm_plug_t *plug, return count; } -static int snd_pcm_plug_playback_channels_mask(snd_pcm_plug_t *plug, - bitset_t *client_vmask) +static int snd_pcm_plug_playback_channels_mask(struct snd_pcm_substream *plug, + unsigned long *client_vmask) { - snd_pcm_plugin_t *plugin = snd_pcm_plug_last(plug); + struct snd_pcm_plugin *plugin = snd_pcm_plug_last(plug); if (plugin == NULL) { return 0; } else { int schannels = plugin->dst_format.channels; - bitset_t bs[bitset_size(schannels)]; - bitset_t *srcmask; - bitset_t *dstmask = bs; + DECLARE_BITMAP(bs, schannels); + unsigned long *srcmask; + unsigned long *dstmask = bs; int err; - bitset_one(dstmask, schannels); + bitmap_fill(dstmask, schannels); while (1) { err = plugin->src_channels_mask(plugin, dstmask, &srcmask); @@ -673,52 +673,52 @@ static int snd_pcm_plug_playback_channels_mask(snd_pcm_plug_t *plug, break; plugin = plugin->prev; } - bitset_and(client_vmask, dstmask, plugin->src_format.channels); + bitmap_and(client_vmask, client_vmask, dstmask, plugin->src_format.channels); return 0; } } -static int snd_pcm_plug_playback_disable_useless_channels(snd_pcm_plug_t *plug, - snd_pcm_plugin_channel_t *src_channels) +static int snd_pcm_plug_playback_disable_useless_channels(struct snd_pcm_substream *plug, + struct snd_pcm_plugin_channel *src_channels) { - snd_pcm_plugin_t *plugin = snd_pcm_plug_first(plug); + struct snd_pcm_plugin *plugin = snd_pcm_plug_first(plug); unsigned int nchannels = plugin->src_format.channels; - bitset_t bs[bitset_size(nchannels)]; - bitset_t *srcmask = bs; + DECLARE_BITMAP(bs, nchannels); + unsigned long *srcmask = bs; int err; unsigned int channel; for (channel = 0; channel < nchannels; channel++) { if (src_channels[channel].enabled) - bitset_set(srcmask, channel); + set_bit(channel, srcmask); else - bitset_reset(srcmask, channel); + clear_bit(channel, srcmask); } err = snd_pcm_plug_playback_channels_mask(plug, srcmask); if (err < 0) return err; for (channel = 0; channel < nchannels; channel++) { - if (!bitset_get(srcmask, channel)) + if (!test_bit(channel, srcmask)) src_channels[channel].enabled = 0; } return 0; } -static int snd_pcm_plug_capture_disable_useless_channels(snd_pcm_plug_t *plug, - snd_pcm_plugin_channel_t *src_channels, - snd_pcm_plugin_channel_t *client_channels) +static int snd_pcm_plug_capture_disable_useless_channels(struct snd_pcm_substream *plug, + struct snd_pcm_plugin_channel *src_channels, + struct snd_pcm_plugin_channel *client_channels) { - snd_pcm_plugin_t *plugin = snd_pcm_plug_last(plug); + struct snd_pcm_plugin *plugin = snd_pcm_plug_last(plug); unsigned int nchannels = plugin->dst_format.channels; - bitset_t bs[bitset_size(nchannels)]; - bitset_t *dstmask = bs; - bitset_t *srcmask; + DECLARE_BITMAP(bs, nchannels); + unsigned long *dstmask = bs; + unsigned long *srcmask; int err; unsigned int channel; for (channel = 0; channel < nchannels; channel++) { if (client_channels[channel].enabled) - bitset_set(dstmask, channel); + set_bit(channel, dstmask); else - bitset_reset(dstmask, channel); + clear_bit(channel, dstmask); } while (plugin) { err = plugin->src_channels_mask(plugin, dstmask, &srcmask); @@ -730,16 +730,16 @@ static int snd_pcm_plug_capture_disable_useless_channels(snd_pcm_plug_t *plug, plugin = snd_pcm_plug_first(plug); nchannels = plugin->src_format.channels; for (channel = 0; channel < nchannels; channel++) { - if (!bitset_get(dstmask, channel)) + if (!test_bit(channel, dstmask)) src_channels[channel].enabled = 0; } return 0; } -snd_pcm_sframes_t snd_pcm_plug_write_transfer(snd_pcm_plug_t *plug, snd_pcm_plugin_channel_t *src_channels, snd_pcm_uframes_t size) +snd_pcm_sframes_t snd_pcm_plug_write_transfer(struct snd_pcm_substream *plug, struct snd_pcm_plugin_channel *src_channels, snd_pcm_uframes_t size) { - snd_pcm_plugin_t *plugin, *next; - snd_pcm_plugin_channel_t *dst_channels; + struct snd_pcm_plugin *plugin, *next; + struct snd_pcm_plugin_channel *dst_channels; int err; snd_pcm_sframes_t frames = size; @@ -771,10 +771,10 @@ snd_pcm_sframes_t snd_pcm_plug_write_transfer(snd_pcm_plug_t *plug, snd_pcm_plug return snd_pcm_plug_client_size(plug, frames); } -snd_pcm_sframes_t snd_pcm_plug_read_transfer(snd_pcm_plug_t *plug, snd_pcm_plugin_channel_t *dst_channels_final, snd_pcm_uframes_t size) +snd_pcm_sframes_t snd_pcm_plug_read_transfer(struct snd_pcm_substream *plug, struct snd_pcm_plugin_channel *dst_channels_final, snd_pcm_uframes_t size) { - snd_pcm_plugin_t *plugin, *next; - snd_pcm_plugin_channel_t *src_channels, *dst_channels; + struct snd_pcm_plugin *plugin, *next; + struct snd_pcm_plugin_channel *src_channels, *dst_channels; snd_pcm_sframes_t frames = size; int err; @@ -806,7 +806,7 @@ snd_pcm_sframes_t snd_pcm_plug_read_transfer(snd_pcm_plug_t *plug, snd_pcm_plugi return frames; } -int snd_pcm_area_silence(const snd_pcm_channel_area_t *dst_area, size_t dst_offset, +int snd_pcm_area_silence(const struct snd_pcm_channel_area *dst_area, size_t dst_offset, size_t samples, int format) { /* FIXME: sub byte resolution and odd dst_offset */ @@ -852,8 +852,8 @@ int snd_pcm_area_silence(const snd_pcm_channel_area_t *dst_area, size_t dst_offs return 0; } -int snd_pcm_area_copy(const snd_pcm_channel_area_t *src_area, size_t src_offset, - const snd_pcm_channel_area_t *dst_area, size_t dst_offset, +int snd_pcm_area_copy(const struct snd_pcm_channel_area *src_area, size_t src_offset, + const struct snd_pcm_channel_area *dst_area, size_t dst_offset, size_t samples, int format) { /* FIXME: sub byte resolution and odd dst_offset */ diff --git a/sound/core/oss/pcm_plugin.h b/sound/core/oss/pcm_plugin.h index 0f86ce47749..29198da615c 100644 --- a/sound/core/oss/pcm_plugin.h +++ b/sound/core/oss/pcm_plugin.h @@ -22,214 +22,164 @@ * */ -#ifndef ATTRIBUTE_UNUSED -#define ATTRIBUTE_UNUSED __attribute__ ((__unused__)) -#endif - -typedef unsigned int bitset_t; - -static inline size_t bitset_size(int nbits) -{ - return (nbits + sizeof(bitset_t) * 8 - 1) / (sizeof(bitset_t) * 8); -} - -static inline bitset_t *bitset_alloc(int nbits) -{ - return kcalloc(bitset_size(nbits), sizeof(bitset_t), GFP_KERNEL); -} - -static inline void bitset_set(bitset_t *bitmap, unsigned int pos) -{ - size_t bits = sizeof(*bitmap) * 8; - bitmap[pos / bits] |= 1 << (pos % bits); -} +#include <linux/bitmap.h> -static inline void bitset_reset(bitset_t *bitmap, unsigned int pos) +static inline unsigned long *bitmap_alloc(unsigned int nbits) { - size_t bits = sizeof(*bitmap) * 8; - bitmap[pos / bits] &= ~(1 << (pos % bits)); + return kmalloc(BITS_TO_LONGS(nbits), GFP_KERNEL); } -static inline int bitset_get(bitset_t *bitmap, unsigned int pos) -{ - size_t bits = sizeof(*bitmap) * 8; - return !!(bitmap[pos / bits] & (1 << (pos % bits))); -} - -static inline void bitset_copy(bitset_t *dst, bitset_t *src, unsigned int nbits) -{ - memcpy(dst, src, bitset_size(nbits) * sizeof(bitset_t)); -} - -static inline void bitset_and(bitset_t *dst, bitset_t *bs, unsigned int nbits) -{ - bitset_t *end = dst + bitset_size(nbits); - while (dst < end) - *dst++ &= *bs++; -} - -static inline void bitset_or(bitset_t *dst, bitset_t *bs, unsigned int nbits) -{ - bitset_t *end = dst + bitset_size(nbits); - while (dst < end) - *dst++ |= *bs++; -} - -static inline void bitset_zero(bitset_t *dst, unsigned int nbits) -{ - bitset_t *end = dst + bitset_size(nbits); - while (dst < end) - *dst++ = 0; -} - -static inline void bitset_one(bitset_t *dst, unsigned int nbits) -{ - bitset_t *end = dst + bitset_size(nbits); - while (dst < end) - *dst++ = ~(bitset_t)0; -} - -#define snd_pcm_plug_t snd_pcm_substream_t #define snd_pcm_plug_stream(plug) ((plug)->stream) -typedef enum { +enum snd_pcm_plugin_action { INIT = 0, PREPARE = 1, -} snd_pcm_plugin_action_t; +}; -typedef struct _snd_pcm_channel_area { +struct snd_pcm_channel_area { void *addr; /* base address of channel samples */ unsigned int first; /* offset to first sample in bits */ unsigned int step; /* samples distance in bits */ -} snd_pcm_channel_area_t; +}; -typedef struct _snd_pcm_plugin_channel { +struct snd_pcm_plugin_channel { void *aptr; /* pointer to the allocated area */ - snd_pcm_channel_area_t area; + struct snd_pcm_channel_area area; snd_pcm_uframes_t frames; /* allocated frames */ unsigned int enabled:1; /* channel need to be processed */ unsigned int wanted:1; /* channel is wanted */ -} snd_pcm_plugin_channel_t; +}; -typedef struct _snd_pcm_plugin_format { +struct snd_pcm_plugin_format { int format; unsigned int rate; unsigned int channels; -} snd_pcm_plugin_format_t; +}; -struct _snd_pcm_plugin { +struct snd_pcm_plugin { const char *name; /* plug-in name */ int stream; - snd_pcm_plugin_format_t src_format; /* source format */ - snd_pcm_plugin_format_t dst_format; /* destination format */ + struct snd_pcm_plugin_format src_format; /* source format */ + struct snd_pcm_plugin_format dst_format; /* destination format */ int src_width; /* sample width in bits */ int dst_width; /* sample width in bits */ int access; - snd_pcm_sframes_t (*src_frames)(snd_pcm_plugin_t *plugin, snd_pcm_uframes_t dst_frames); - snd_pcm_sframes_t (*dst_frames)(snd_pcm_plugin_t *plugin, snd_pcm_uframes_t src_frames); - snd_pcm_sframes_t (*client_channels)(snd_pcm_plugin_t *plugin, - snd_pcm_uframes_t frames, - snd_pcm_plugin_channel_t **channels); - int (*src_channels_mask)(snd_pcm_plugin_t *plugin, - bitset_t *dst_vmask, - bitset_t **src_vmask); - int (*dst_channels_mask)(snd_pcm_plugin_t *plugin, - bitset_t *src_vmask, - bitset_t **dst_vmask); - snd_pcm_sframes_t (*transfer)(snd_pcm_plugin_t *plugin, - const snd_pcm_plugin_channel_t *src_channels, - snd_pcm_plugin_channel_t *dst_channels, - snd_pcm_uframes_t frames); - int (*action)(snd_pcm_plugin_t *plugin, - snd_pcm_plugin_action_t action, + snd_pcm_sframes_t (*src_frames)(struct snd_pcm_plugin *plugin, snd_pcm_uframes_t dst_frames); + snd_pcm_sframes_t (*dst_frames)(struct snd_pcm_plugin *plugin, snd_pcm_uframes_t src_frames); + snd_pcm_sframes_t (*client_channels)(struct snd_pcm_plugin *plugin, + snd_pcm_uframes_t frames, + struct snd_pcm_plugin_channel **channels); + int (*src_channels_mask)(struct snd_pcm_plugin *plugin, + unsigned long *dst_vmask, + unsigned long **src_vmask); + int (*dst_channels_mask)(struct snd_pcm_plugin *plugin, + unsigned long *src_vmask, + unsigned long **dst_vmask); + snd_pcm_sframes_t (*transfer)(struct snd_pcm_plugin *plugin, + const struct snd_pcm_plugin_channel *src_channels, + struct snd_pcm_plugin_channel *dst_channels, + snd_pcm_uframes_t frames); + int (*action)(struct snd_pcm_plugin *plugin, + enum snd_pcm_plugin_action action, unsigned long data); - snd_pcm_plugin_t *prev; - snd_pcm_plugin_t *next; - snd_pcm_plug_t *plug; + struct snd_pcm_plugin *prev; + struct snd_pcm_plugin *next; + struct snd_pcm_substream *plug; void *private_data; - void (*private_free)(snd_pcm_plugin_t *plugin); + void (*private_free)(struct snd_pcm_plugin *plugin); char *buf; snd_pcm_uframes_t buf_frames; - snd_pcm_plugin_channel_t *buf_channels; - bitset_t *src_vmask; - bitset_t *dst_vmask; + struct snd_pcm_plugin_channel *buf_channels; + unsigned long *src_vmask; + unsigned long *dst_vmask; char extra_data[0]; }; -int snd_pcm_plugin_build(snd_pcm_plug_t *handle, +int snd_pcm_plugin_build(struct snd_pcm_substream *handle, const char *name, - snd_pcm_plugin_format_t *src_format, - snd_pcm_plugin_format_t *dst_format, + struct snd_pcm_plugin_format *src_format, + struct snd_pcm_plugin_format *dst_format, size_t extra, - snd_pcm_plugin_t **ret); -int snd_pcm_plugin_free(snd_pcm_plugin_t *plugin); -int snd_pcm_plugin_clear(snd_pcm_plugin_t **first); -int snd_pcm_plug_alloc(snd_pcm_plug_t *plug, snd_pcm_uframes_t frames); -snd_pcm_sframes_t snd_pcm_plug_client_size(snd_pcm_plug_t *handle, snd_pcm_uframes_t drv_size); -snd_pcm_sframes_t snd_pcm_plug_slave_size(snd_pcm_plug_t *handle, snd_pcm_uframes_t clt_size); + struct snd_pcm_plugin **ret); +int snd_pcm_plugin_free(struct snd_pcm_plugin *plugin); +int snd_pcm_plugin_clear(struct snd_pcm_plugin **first); +int snd_pcm_plug_alloc(struct snd_pcm_substream *plug, snd_pcm_uframes_t frames); +snd_pcm_sframes_t snd_pcm_plug_client_size(struct snd_pcm_substream *handle, snd_pcm_uframes_t drv_size); +snd_pcm_sframes_t snd_pcm_plug_slave_size(struct snd_pcm_substream *handle, snd_pcm_uframes_t clt_size); #define FULL ROUTE_PLUGIN_RESOLUTION #define HALF ROUTE_PLUGIN_RESOLUTION / 2 -typedef int route_ttable_entry_t; - -int snd_pcm_plugin_build_io(snd_pcm_plug_t *handle, - snd_pcm_hw_params_t *params, - snd_pcm_plugin_t **r_plugin); -int snd_pcm_plugin_build_linear(snd_pcm_plug_t *handle, - snd_pcm_plugin_format_t *src_format, - snd_pcm_plugin_format_t *dst_format, - snd_pcm_plugin_t **r_plugin); -int snd_pcm_plugin_build_mulaw(snd_pcm_plug_t *handle, - snd_pcm_plugin_format_t *src_format, - snd_pcm_plugin_format_t *dst_format, - snd_pcm_plugin_t **r_plugin); -int snd_pcm_plugin_build_rate(snd_pcm_plug_t *handle, - snd_pcm_plugin_format_t *src_format, - snd_pcm_plugin_format_t *dst_format, - snd_pcm_plugin_t **r_plugin); -int snd_pcm_plugin_build_route(snd_pcm_plug_t *handle, - snd_pcm_plugin_format_t *src_format, - snd_pcm_plugin_format_t *dst_format, - route_ttable_entry_t *ttable, - snd_pcm_plugin_t **r_plugin); -int snd_pcm_plugin_build_copy(snd_pcm_plug_t *handle, - snd_pcm_plugin_format_t *src_format, - snd_pcm_plugin_format_t *dst_format, - snd_pcm_plugin_t **r_plugin); - -int snd_pcm_plug_format_plugins(snd_pcm_plug_t *substream, - snd_pcm_hw_params_t *params, - snd_pcm_hw_params_t *slave_params); - -int snd_pcm_plug_slave_format(int format, snd_mask_t *format_mask); - -int snd_pcm_plugin_append(snd_pcm_plugin_t *plugin); - -snd_pcm_sframes_t snd_pcm_plug_write_transfer(snd_pcm_plug_t *handle, snd_pcm_plugin_channel_t *src_channels, snd_pcm_uframes_t size); -snd_pcm_sframes_t snd_pcm_plug_read_transfer(snd_pcm_plug_t *handle, snd_pcm_plugin_channel_t *dst_channels_final, snd_pcm_uframes_t size); - -snd_pcm_sframes_t snd_pcm_plug_client_channels_buf(snd_pcm_plug_t *handle, - char *buf, snd_pcm_uframes_t count, - snd_pcm_plugin_channel_t **channels); - -snd_pcm_sframes_t snd_pcm_plugin_client_channels(snd_pcm_plugin_t *plugin, - snd_pcm_uframes_t frames, - snd_pcm_plugin_channel_t **channels); - -int snd_pcm_area_silence(const snd_pcm_channel_area_t *dst_channel, size_t dst_offset, + +int snd_pcm_plugin_build_io(struct snd_pcm_substream *handle, + struct snd_pcm_hw_params *params, + struct snd_pcm_plugin **r_plugin); +int snd_pcm_plugin_build_linear(struct snd_pcm_substream *handle, + struct snd_pcm_plugin_format *src_format, + struct snd_pcm_plugin_format *dst_format, + struct snd_pcm_plugin **r_plugin); +int snd_pcm_plugin_build_mulaw(struct snd_pcm_substream *handle, + struct snd_pcm_plugin_format *src_format, + struct snd_pcm_plugin_format *dst_format, + struct snd_pcm_plugin **r_plugin); +int snd_pcm_plugin_build_rate(struct snd_pcm_substream *handle, + struct snd_pcm_plugin_format *src_format, + struct snd_pcm_plugin_format *dst_format, + struct snd_pcm_plugin **r_plugin); +int snd_pcm_plugin_build_route(struct snd_pcm_substream *handle, + struct snd_pcm_plugin_format *src_format, + struct snd_pcm_plugin_format *dst_format, + int *ttable, + struct snd_pcm_plugin **r_plugin); +int snd_pcm_plugin_build_copy(struct snd_pcm_substream *handle, + struct snd_pcm_plugin_format *src_format, + struct snd_pcm_plugin_format *dst_format, + struct snd_pcm_plugin **r_plugin); + +int snd_pcm_plug_format_plugins(struct snd_pcm_substream *substream, + struct snd_pcm_hw_params *params, + struct snd_pcm_hw_params *slave_params); + +int snd_pcm_plug_slave_format(int format, struct snd_mask *format_mask); + +int snd_pcm_plugin_append(struct snd_pcm_plugin *plugin); + +snd_pcm_sframes_t snd_pcm_plug_write_transfer(struct snd_pcm_substream *handle, + struct snd_pcm_plugin_channel *src_channels, + snd_pcm_uframes_t size); +snd_pcm_sframes_t snd_pcm_plug_read_transfer(struct snd_pcm_substream *handle, + struct snd_pcm_plugin_channel *dst_channels_final, + snd_pcm_uframes_t size); + +snd_pcm_sframes_t snd_pcm_plug_client_channels_buf(struct snd_pcm_substream *handle, + char *buf, snd_pcm_uframes_t count, + struct snd_pcm_plugin_channel **channels); + +snd_pcm_sframes_t snd_pcm_plugin_client_channels(struct snd_pcm_plugin *plugin, + snd_pcm_uframes_t frames, + struct snd_pcm_plugin_channel **channels); + +int snd_pcm_area_silence(const struct snd_pcm_channel_area *dst_channel, + size_t dst_offset, size_t samples, int format); -int snd_pcm_area_copy(const snd_pcm_channel_area_t *src_channel, size_t src_offset, - const snd_pcm_channel_area_t *dst_channel, size_t dst_offset, +int snd_pcm_area_copy(const struct snd_pcm_channel_area *src_channel, + size_t src_offset, + const struct snd_pcm_channel_area *dst_channel, + size_t dst_offset, size_t samples, int format); -void *snd_pcm_plug_buf_alloc(snd_pcm_plug_t *plug, snd_pcm_uframes_t size); -void snd_pcm_plug_buf_unlock(snd_pcm_plug_t *plug, void *ptr); -snd_pcm_sframes_t snd_pcm_oss_write3(snd_pcm_substream_t *substream, const char *ptr, snd_pcm_uframes_t size, int in_kernel); -snd_pcm_sframes_t snd_pcm_oss_read3(snd_pcm_substream_t *substream, char *ptr, snd_pcm_uframes_t size, int in_kernel); -snd_pcm_sframes_t snd_pcm_oss_writev3(snd_pcm_substream_t *substream, void **bufs, snd_pcm_uframes_t frames, int in_kernel); -snd_pcm_sframes_t snd_pcm_oss_readv3(snd_pcm_substream_t *substream, void **bufs, snd_pcm_uframes_t frames, int in_kernel); - - +void *snd_pcm_plug_buf_alloc(struct snd_pcm_substream *plug, snd_pcm_uframes_t size); +void snd_pcm_plug_buf_unlock(struct snd_pcm_substream *plug, void *ptr); +snd_pcm_sframes_t snd_pcm_oss_write3(struct snd_pcm_substream *substream, + const char *ptr, snd_pcm_uframes_t size, + int in_kernel); +snd_pcm_sframes_t snd_pcm_oss_read3(struct snd_pcm_substream *substream, + char *ptr, snd_pcm_uframes_t size, int in_kernel); +snd_pcm_sframes_t snd_pcm_oss_writev3(struct snd_pcm_substream *substream, + void **bufs, snd_pcm_uframes_t frames, + int in_kernel); +snd_pcm_sframes_t snd_pcm_oss_readv3(struct snd_pcm_substream *substream, + void **bufs, snd_pcm_uframes_t frames, + int in_kernel); #define ROUTE_PLUGIN_RESOLUTION 16 @@ -237,8 +187,8 @@ int getput_index(int format); int copy_index(int format); int conv_index(int src_format, int dst_format); -void zero_channel(snd_pcm_plugin_t *plugin, - const snd_pcm_plugin_channel_t *dst_channel, +void zero_channel(struct snd_pcm_plugin *plugin, + const struct snd_pcm_plugin_channel *dst_channel, size_t samples); #ifdef PLUGIN_DEBUG diff --git a/sound/core/oss/rate.c b/sound/core/oss/rate.c index 1096ec18671..4854cef6fb4 100644 --- a/sound/core/oss/rate.c +++ b/sound/core/oss/rate.c @@ -33,29 +33,29 @@ * Basic rate conversion plugin */ -typedef struct { +struct rate_channel { signed short last_S1; signed short last_S2; -} rate_channel_t; +}; -typedef void (*rate_f)(snd_pcm_plugin_t *plugin, - const snd_pcm_plugin_channel_t *src_channels, - snd_pcm_plugin_channel_t *dst_channels, +typedef void (*rate_f)(struct snd_pcm_plugin *plugin, + const struct snd_pcm_plugin_channel *src_channels, + struct snd_pcm_plugin_channel *dst_channels, int src_frames, int dst_frames); -typedef struct rate_private_data { +struct rate_priv { unsigned int pitch; unsigned int pos; rate_f func; int get, put; snd_pcm_sframes_t old_src_frames, old_dst_frames; - rate_channel_t channels[0]; -} rate_t; + struct rate_channel channels[0]; +}; -static void rate_init(snd_pcm_plugin_t *plugin) +static void rate_init(struct snd_pcm_plugin *plugin) { unsigned int channel; - rate_t *data = (rate_t *)plugin->extra_data; + struct rate_priv *data = (struct rate_priv *)plugin->extra_data; data->pos = 0; for (channel = 0; channel < plugin->src_format.channels; channel++) { data->channels[channel].last_S1 = 0; @@ -63,9 +63,9 @@ static void rate_init(snd_pcm_plugin_t *plugin) } } -static void resample_expand(snd_pcm_plugin_t *plugin, - const snd_pcm_plugin_channel_t *src_channels, - snd_pcm_plugin_channel_t *dst_channels, +static void resample_expand(struct snd_pcm_plugin *plugin, + const struct snd_pcm_plugin_channel *src_channels, + struct snd_pcm_plugin_channel *dst_channels, int src_frames, int dst_frames) { unsigned int pos = 0; @@ -75,8 +75,8 @@ static void resample_expand(snd_pcm_plugin_t *plugin, unsigned int channel; int src_step, dst_step; int src_frames1, dst_frames1; - rate_t *data = (rate_t *)plugin->extra_data; - rate_channel_t *rchannels = data->channels; + struct rate_priv *data = (struct rate_priv *)plugin->extra_data; + struct rate_channel *rchannels = data->channels; #define GET_S16_LABELS #define PUT_S16_LABELS @@ -139,9 +139,9 @@ static void resample_expand(snd_pcm_plugin_t *plugin, data->pos = pos; } -static void resample_shrink(snd_pcm_plugin_t *plugin, - const snd_pcm_plugin_channel_t *src_channels, - snd_pcm_plugin_channel_t *dst_channels, +static void resample_shrink(struct snd_pcm_plugin *plugin, + const struct snd_pcm_plugin_channel *src_channels, + struct snd_pcm_plugin_channel *dst_channels, int src_frames, int dst_frames) { unsigned int pos = 0; @@ -151,8 +151,8 @@ static void resample_shrink(snd_pcm_plugin_t *plugin, unsigned int channel; int src_step, dst_step; int src_frames1, dst_frames1; - rate_t *data = (rate_t *)plugin->extra_data; - rate_channel_t *rchannels = data->channels; + struct rate_priv *data = (struct rate_priv *)plugin->extra_data; + struct rate_channel *rchannels = data->channels; #define GET_S16_LABELS #define PUT_S16_LABELS @@ -216,15 +216,15 @@ static void resample_shrink(snd_pcm_plugin_t *plugin, data->pos = pos; } -static snd_pcm_sframes_t rate_src_frames(snd_pcm_plugin_t *plugin, snd_pcm_uframes_t frames) +static snd_pcm_sframes_t rate_src_frames(struct snd_pcm_plugin *plugin, snd_pcm_uframes_t frames) { - rate_t *data; + struct rate_priv *data; snd_pcm_sframes_t res; snd_assert(plugin != NULL, return -ENXIO); if (frames == 0) return 0; - data = (rate_t *)plugin->extra_data; + data = (struct rate_priv *)plugin->extra_data; if (plugin->src_format.rate < plugin->dst_format.rate) { res = (((frames * data->pitch) + (BITS/2)) >> SHIFT); } else { @@ -248,15 +248,15 @@ static snd_pcm_sframes_t rate_src_frames(snd_pcm_plugin_t *plugin, snd_pcm_ufram return res; } -static snd_pcm_sframes_t rate_dst_frames(snd_pcm_plugin_t *plugin, snd_pcm_uframes_t frames) +static snd_pcm_sframes_t rate_dst_frames(struct snd_pcm_plugin *plugin, snd_pcm_uframes_t frames) { - rate_t *data; + struct rate_priv *data; snd_pcm_sframes_t res; snd_assert(plugin != NULL, return -ENXIO); if (frames == 0) return 0; - data = (rate_t *)plugin->extra_data; + data = (struct rate_priv *)plugin->extra_data; if (plugin->src_format.rate < plugin->dst_format.rate) { res = (((frames << SHIFT) + (data->pitch / 2)) / data->pitch); } else { @@ -280,13 +280,13 @@ static snd_pcm_sframes_t rate_dst_frames(snd_pcm_plugin_t *plugin, snd_pcm_ufram return res; } -static snd_pcm_sframes_t rate_transfer(snd_pcm_plugin_t *plugin, - const snd_pcm_plugin_channel_t *src_channels, - snd_pcm_plugin_channel_t *dst_channels, +static snd_pcm_sframes_t rate_transfer(struct snd_pcm_plugin *plugin, + const struct snd_pcm_plugin_channel *src_channels, + struct snd_pcm_plugin_channel *dst_channels, snd_pcm_uframes_t frames) { snd_pcm_uframes_t dst_frames; - rate_t *data; + struct rate_priv *data; snd_assert(plugin != NULL && src_channels != NULL && dst_channels != NULL, return -ENXIO); if (frames == 0) @@ -308,14 +308,14 @@ static snd_pcm_sframes_t rate_transfer(snd_pcm_plugin_t *plugin, dst_frames = rate_dst_frames(plugin, frames); if (dst_frames > dst_channels[0].frames) dst_frames = dst_channels[0].frames; - data = (rate_t *)plugin->extra_data; + data = (struct rate_priv *)plugin->extra_data; data->func(plugin, src_channels, dst_channels, frames, dst_frames); return dst_frames; } -static int rate_action(snd_pcm_plugin_t *plugin, - snd_pcm_plugin_action_t action, - unsigned long udata ATTRIBUTE_UNUSED) +static int rate_action(struct snd_pcm_plugin *plugin, + enum snd_pcm_plugin_action action, + unsigned long udata) { snd_assert(plugin != NULL, return -ENXIO); switch (action) { @@ -329,14 +329,14 @@ static int rate_action(snd_pcm_plugin_t *plugin, return 0; /* silenty ignore other actions */ } -int snd_pcm_plugin_build_rate(snd_pcm_plug_t *plug, - snd_pcm_plugin_format_t *src_format, - snd_pcm_plugin_format_t *dst_format, - snd_pcm_plugin_t **r_plugin) +int snd_pcm_plugin_build_rate(struct snd_pcm_substream *plug, + struct snd_pcm_plugin_format *src_format, + struct snd_pcm_plugin_format *dst_format, + struct snd_pcm_plugin **r_plugin) { int err; - rate_t *data; - snd_pcm_plugin_t *plugin; + struct rate_priv *data; + struct snd_pcm_plugin *plugin; snd_assert(r_plugin != NULL, return -ENXIO); *r_plugin = NULL; @@ -349,11 +349,12 @@ int snd_pcm_plugin_build_rate(snd_pcm_plug_t *plug, err = snd_pcm_plugin_build(plug, "rate conversion", src_format, dst_format, - sizeof(rate_t) + src_format->channels * sizeof(rate_channel_t), + sizeof(struct rate_priv) + + src_format->channels * sizeof(struct rate_channel), &plugin); if (err < 0) return err; - data = (rate_t *)plugin->extra_data; + data = (struct rate_priv *)plugin->extra_data; data->get = getput_index(src_format->format); snd_assert(data->get >= 0 && data->get < 4*2*2, return -EINVAL); data->put = getput_index(dst_format->format); diff --git a/sound/core/oss/route.c b/sound/core/oss/route.c index c955b7dfdb3..726c5caa3fd 100644 --- a/sound/core/oss/route.c +++ b/sound/core/oss/route.c @@ -35,61 +35,62 @@ #error "Add some code here" #endif -typedef struct ttable_dst ttable_dst_t; -typedef struct route_private_data route_t; +struct ttable_dst; -typedef void (*route_channel_f)(snd_pcm_plugin_t *plugin, - const snd_pcm_plugin_channel_t *src_channels, - snd_pcm_plugin_channel_t *dst_channel, - ttable_dst_t* ttable, snd_pcm_uframes_t frames); +typedef void (*route_channel_f)(struct snd_pcm_plugin *plugin, + const struct snd_pcm_plugin_channel *src_channels, + struct snd_pcm_plugin_channel *dst_channel, + struct ttable_dst *ttable, snd_pcm_uframes_t frames); -typedef struct { +struct ttable_src { int channel; int as_int; -} ttable_src_t; +}; struct ttable_dst { int att; /* Attenuated */ unsigned int nsrcs; - ttable_src_t* srcs; + struct ttable_src *srcs; route_channel_f func; }; -struct route_private_data { +struct route_priv { enum {R_UINT32=0, R_UINT64=1} sum_type; int get, put; int conv; int src_sample_size; - ttable_dst_t ttable[0]; + struct ttable_dst ttable[0]; }; -typedef union { +union sum { u_int32_t as_uint32; u_int64_t as_uint64; -} sum_t; +}; -static void route_to_channel_from_zero(snd_pcm_plugin_t *plugin, - const snd_pcm_plugin_channel_t *src_channels ATTRIBUTE_UNUSED, - snd_pcm_plugin_channel_t *dst_channel, - ttable_dst_t* ttable ATTRIBUTE_UNUSED, snd_pcm_uframes_t frames) +static void route_to_channel_from_zero(struct snd_pcm_plugin *plugin, + const struct snd_pcm_plugin_channel *src_channels, + struct snd_pcm_plugin_channel *dst_channel, + struct ttable_dst *ttable, + snd_pcm_uframes_t frames) { if (dst_channel->wanted) snd_pcm_area_silence(&dst_channel->area, 0, frames, plugin->dst_format.format); dst_channel->enabled = 0; } -static void route_to_channel_from_one(snd_pcm_plugin_t *plugin, - const snd_pcm_plugin_channel_t *src_channels, - snd_pcm_plugin_channel_t *dst_channel, - ttable_dst_t* ttable, snd_pcm_uframes_t frames) +static void route_to_channel_from_one(struct snd_pcm_plugin *plugin, + const struct snd_pcm_plugin_channel *src_channels, + struct snd_pcm_plugin_channel *dst_channel, + struct ttable_dst *ttable, + snd_pcm_uframes_t frames) { #define CONV_LABELS #include "plugin_ops.h" #undef CONV_LABELS - route_t *data = (route_t *)plugin->extra_data; + struct route_priv *data = (struct route_priv *)plugin->extra_data; void *conv; - const snd_pcm_plugin_channel_t *src_channel = NULL; + const struct snd_pcm_plugin_channel *src_channel = NULL; unsigned int srcidx; char *src, *dst; int src_step, dst_step; @@ -120,10 +121,10 @@ static void route_to_channel_from_one(snd_pcm_plugin_t *plugin, } } -static void route_to_channel(snd_pcm_plugin_t *plugin, - const snd_pcm_plugin_channel_t *src_channels, - snd_pcm_plugin_channel_t *dst_channel, - ttable_dst_t* ttable, snd_pcm_uframes_t frames) +static void route_to_channel(struct snd_pcm_plugin *plugin, + const struct snd_pcm_plugin_channel *src_channels, + struct snd_pcm_plugin_channel *dst_channel, + struct ttable_dst *ttable, snd_pcm_uframes_t frames) { #define GET_U_LABELS #define PUT_U32_LABELS @@ -153,18 +154,18 @@ static void route_to_channel(snd_pcm_plugin_t *plugin, &&norm_int64_16_att, &&norm_int64_24_att, }; - route_t *data = (route_t *)plugin->extra_data; + struct route_priv *data = (struct route_priv *)plugin->extra_data; void *zero, *get, *add, *norm, *put_u32; int nsrcs = ttable->nsrcs; char *dst; int dst_step; char *srcs[nsrcs]; int src_steps[nsrcs]; - ttable_src_t src_tt[nsrcs]; + struct ttable_src src_tt[nsrcs]; u_int32_t sample = 0; int srcidx, srcidx1 = 0; for (srcidx = 0; srcidx < nsrcs; ++srcidx) { - const snd_pcm_plugin_channel_t *src_channel = &src_channels[ttable->srcs[srcidx].channel]; + const struct snd_pcm_plugin_channel *src_channel = &src_channels[ttable->srcs[srcidx].channel]; if (!src_channel->enabled) continue; srcs[srcidx1] = src_channel->area.addr + src_channel->area.first / 8; @@ -191,8 +192,8 @@ static void route_to_channel(snd_pcm_plugin_t *plugin, dst_step = dst_channel->area.step / 8; while (frames-- > 0) { - ttable_src_t *ttp = src_tt; - sum_t sum; + struct ttable_src *ttp = src_tt; + union sum sum; /* Zero sum */ goto *zero; @@ -297,47 +298,47 @@ static void route_to_channel(snd_pcm_plugin_t *plugin, } } -static int route_src_channels_mask(snd_pcm_plugin_t *plugin, - bitset_t *dst_vmask, - bitset_t **src_vmask) +static int route_src_channels_mask(struct snd_pcm_plugin *plugin, + unsigned long *dst_vmask, + unsigned long **src_vmask) { - route_t *data = (route_t *)plugin->extra_data; + struct route_priv *data = (struct route_priv *)plugin->extra_data; int schannels = plugin->src_format.channels; int dchannels = plugin->dst_format.channels; - bitset_t *vmask = plugin->src_vmask; + unsigned long *vmask = plugin->src_vmask; int channel; - ttable_dst_t *dp = data->ttable; - bitset_zero(vmask, schannels); + struct ttable_dst *dp = data->ttable; + bitmap_zero(vmask, schannels); for (channel = 0; channel < dchannels; channel++, dp++) { unsigned int src; - ttable_src_t *sp; - if (!bitset_get(dst_vmask, channel)) + struct ttable_src *sp; + if (!test_bit(channel, dst_vmask)) continue; sp = dp->srcs; for (src = 0; src < dp->nsrcs; src++, sp++) - bitset_set(vmask, sp->channel); + set_bit(sp->channel, vmask); } *src_vmask = vmask; return 0; } -static int route_dst_channels_mask(snd_pcm_plugin_t *plugin, - bitset_t *src_vmask, - bitset_t **dst_vmask) +static int route_dst_channels_mask(struct snd_pcm_plugin *plugin, + unsigned long *src_vmask, + unsigned long **dst_vmask) { - route_t *data = (route_t *)plugin->extra_data; + struct route_priv *data = (struct route_priv *)plugin->extra_data; int dchannels = plugin->dst_format.channels; - bitset_t *vmask = plugin->dst_vmask; + unsigned long *vmask = plugin->dst_vmask; int channel; - ttable_dst_t *dp = data->ttable; - bitset_zero(vmask, dchannels); + struct ttable_dst *dp = data->ttable; + bitmap_zero(vmask, dchannels); for (channel = 0; channel < dchannels; channel++, dp++) { unsigned int src; - ttable_src_t *sp; + struct ttable_src *sp; sp = dp->srcs; for (src = 0; src < dp->nsrcs; src++, sp++) { - if (bitset_get(src_vmask, sp->channel)) { - bitset_set(vmask, channel); + if (test_bit(sp->channel, src_vmask)) { + set_bit(channel, vmask); break; } } @@ -346,33 +347,33 @@ static int route_dst_channels_mask(snd_pcm_plugin_t *plugin, return 0; } -static void route_free(snd_pcm_plugin_t *plugin) +static void route_free(struct snd_pcm_plugin *plugin) { - route_t *data = (route_t *)plugin->extra_data; + struct route_priv *data = (struct route_priv *)plugin->extra_data; unsigned int dst_channel; for (dst_channel = 0; dst_channel < plugin->dst_format.channels; ++dst_channel) { kfree(data->ttable[dst_channel].srcs); } } -static int route_load_ttable(snd_pcm_plugin_t *plugin, - const route_ttable_entry_t* src_ttable) +static int route_load_ttable(struct snd_pcm_plugin *plugin, + const int *src_ttable) { - route_t *data; + struct route_priv *data; unsigned int src_channel, dst_channel; - const route_ttable_entry_t *sptr; - ttable_dst_t *dptr; + const int *sptr; + struct ttable_dst *dptr; if (src_ttable == NULL) return 0; - data = (route_t *)plugin->extra_data; + data = (struct route_priv *)plugin->extra_data; dptr = data->ttable; sptr = src_ttable; plugin->private_free = route_free; for (dst_channel = 0; dst_channel < plugin->dst_format.channels; ++dst_channel) { - route_ttable_entry_t t = 0; + int t = 0; int att = 0; int nsrcs = 0; - ttable_src_t srcs[plugin->src_format.channels]; + struct ttable_src srcs[plugin->src_format.channels]; for (src_channel = 0; src_channel < plugin->src_format.channels; ++src_channel) { snd_assert(*sptr >= 0 || *sptr <= FULL, return -ENXIO); if (*sptr != 0) { @@ -405,21 +406,21 @@ static int route_load_ttable(snd_pcm_plugin_t *plugin, return 0; } -static snd_pcm_sframes_t route_transfer(snd_pcm_plugin_t *plugin, - const snd_pcm_plugin_channel_t *src_channels, - snd_pcm_plugin_channel_t *dst_channels, +static snd_pcm_sframes_t route_transfer(struct snd_pcm_plugin *plugin, + const struct snd_pcm_plugin_channel *src_channels, + struct snd_pcm_plugin_channel *dst_channels, snd_pcm_uframes_t frames) { - route_t *data; + struct route_priv *data; int src_nchannels, dst_nchannels; int dst_channel; - ttable_dst_t *ttp; - snd_pcm_plugin_channel_t *dvp; + struct ttable_dst *ttp; + struct snd_pcm_plugin_channel *dvp; snd_assert(plugin != NULL && src_channels != NULL && dst_channels != NULL, return -ENXIO); if (frames == 0) return 0; - data = (route_t *)plugin->extra_data; + data = (struct route_priv *)plugin->extra_data; src_nchannels = plugin->src_format.channels; dst_nchannels = plugin->dst_format.channels; @@ -469,14 +470,14 @@ int getput_index(int format) return width * 4 + endian * 2 + sign; } -int snd_pcm_plugin_build_route(snd_pcm_plug_t *plug, - snd_pcm_plugin_format_t *src_format, - snd_pcm_plugin_format_t *dst_format, - route_ttable_entry_t *ttable, - snd_pcm_plugin_t **r_plugin) +int snd_pcm_plugin_build_route(struct snd_pcm_substream *plug, + struct snd_pcm_plugin_format *src_format, + struct snd_pcm_plugin_format *dst_format, + int *ttable, + struct snd_pcm_plugin **r_plugin) { - route_t *data; - snd_pcm_plugin_t *plugin; + struct route_priv *data; + struct snd_pcm_plugin *plugin; int err; snd_assert(r_plugin != NULL, return -ENXIO); @@ -488,12 +489,13 @@ int snd_pcm_plugin_build_route(snd_pcm_plug_t *plug, err = snd_pcm_plugin_build(plug, "attenuated route conversion", src_format, dst_format, - sizeof(route_t) + sizeof(data->ttable[0]) * dst_format->channels, + sizeof(struct route_priv) + + sizeof(data->ttable[0]) * dst_format->channels, &plugin); if (err < 0) return err; - data = (route_t *) plugin->extra_data; + data = (struct route_priv *)plugin->extra_data; data->get = getput_index(src_format->format); snd_assert(data->get >= 0 && data->get < 4*2*2, return -EINVAL); diff --git a/sound/core/pcm.c b/sound/core/pcm.c index 184e74b75ba..28ca61eb0b0 100644 --- a/sound/core/pcm.c +++ b/sound/core/pcm.c @@ -33,23 +33,33 @@ MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>, Abramo Bagnara <abramo@alsa-proj MODULE_DESCRIPTION("Midlevel PCM code for ALSA."); MODULE_LICENSE("GPL"); -snd_pcm_t *snd_pcm_devices[SNDRV_CARDS * SNDRV_PCM_DEVICES]; +static LIST_HEAD(snd_pcm_devices); static LIST_HEAD(snd_pcm_notify_list); static DECLARE_MUTEX(register_mutex); -static int snd_pcm_free(snd_pcm_t *pcm); -static int snd_pcm_dev_free(snd_device_t *device); -static int snd_pcm_dev_register(snd_device_t *device); -static int snd_pcm_dev_disconnect(snd_device_t *device); -static int snd_pcm_dev_unregister(snd_device_t *device); +static int snd_pcm_free(struct snd_pcm *pcm); +static int snd_pcm_dev_free(struct snd_device *device); +static int snd_pcm_dev_register(struct snd_device *device); +static int snd_pcm_dev_disconnect(struct snd_device *device); +static int snd_pcm_dev_unregister(struct snd_device *device); -static int snd_pcm_control_ioctl(snd_card_t * card, - snd_ctl_file_t * control, - unsigned int cmd, unsigned long arg) +static struct snd_pcm *snd_pcm_search(struct snd_card *card, int device) { - unsigned int tmp; + struct list_head *p; + struct snd_pcm *pcm; + + list_for_each(p, &snd_pcm_devices) { + pcm = list_entry(p, struct snd_pcm, list); + if (pcm->card == card && pcm->device == device) + return pcm; + } + return NULL; +} - tmp = card->number * SNDRV_PCM_DEVICES; +static int snd_pcm_control_ioctl(struct snd_card *card, + struct snd_ctl_file *control, + unsigned int cmd, unsigned long arg) +{ switch (cmd) { case SNDRV_CTL_IOCTL_PCM_NEXT_DEVICE: { @@ -57,51 +67,66 @@ static int snd_pcm_control_ioctl(snd_card_t * 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; } case SNDRV_CTL_IOCTL_PCM_INFO: { - snd_pcm_info_t __user *info; + struct snd_pcm_info __user *info; unsigned int device, subdevice; - snd_pcm_stream_t stream; - snd_pcm_t *pcm; - snd_pcm_str_t *pstr; - snd_pcm_substream_t *substream; - info = (snd_pcm_info_t __user *)arg; + int stream; + struct snd_pcm *pcm; + struct snd_pcm_str *pstr; + struct snd_pcm_substream *substream; + 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: { @@ -126,30 +151,6 @@ static int snd_pcm_control_ioctl(snd_card_t * card, #define FORMAT(v) [SNDRV_PCM_FORMAT_##v] = #v #define SUBFORMAT(v) [SNDRV_PCM_SUBFORMAT_##v] = #v -static char *snd_pcm_stream_names[] = { - STREAM(PLAYBACK), - STREAM(CAPTURE), -}; - -static char *snd_pcm_state_names[] = { - STATE(OPEN), - STATE(SETUP), - STATE(PREPARED), - STATE(RUNNING), - STATE(XRUN), - STATE(DRAINING), - STATE(PAUSED), - STATE(SUSPENDED), -}; - -static char *snd_pcm_access_names[] = { - ACCESS(MMAP_INTERLEAVED), - ACCESS(MMAP_NONINTERLEAVED), - ACCESS(MMAP_COMPLEX), - ACCESS(RW_INTERLEAVED), - ACCESS(RW_NONINTERLEAVED), -}; - static char *snd_pcm_format_names[] = { FORMAT(S8), FORMAT(U8), @@ -191,6 +192,36 @@ static char *snd_pcm_format_names[] = { FORMAT(U18_3BE), }; +const char *snd_pcm_format_name(snd_pcm_format_t format) +{ + return snd_pcm_format_names[format]; +} + +#ifdef CONFIG_PROC_FS +static char *snd_pcm_stream_names[] = { + STREAM(PLAYBACK), + STREAM(CAPTURE), +}; + +static char *snd_pcm_state_names[] = { + STATE(OPEN), + STATE(SETUP), + STATE(PREPARED), + STATE(RUNNING), + STATE(XRUN), + STATE(DRAINING), + STATE(PAUSED), + STATE(SUSPENDED), +}; + +static char *snd_pcm_access_names[] = { + ACCESS(MMAP_INTERLEAVED), + ACCESS(MMAP_NONINTERLEAVED), + ACCESS(MMAP_COMPLEX), + ACCESS(RW_INTERLEAVED), + ACCESS(RW_NONINTERLEAVED), +}; + static char *snd_pcm_subformat_names[] = { SUBFORMAT(STD), }; @@ -200,7 +231,7 @@ static char *snd_pcm_tstamp_mode_names[] = { TSTAMP(MMAP), }; -static const char *snd_pcm_stream_name(snd_pcm_stream_t stream) +static const char *snd_pcm_stream_name(int stream) { snd_assert(stream <= SNDRV_PCM_STREAM_LAST, return NULL); return snd_pcm_stream_names[stream]; @@ -208,23 +239,15 @@ static const char *snd_pcm_stream_name(snd_pcm_stream_t stream) static const char *snd_pcm_access_name(snd_pcm_access_t access) { - snd_assert(access <= SNDRV_PCM_ACCESS_LAST, return NULL); return snd_pcm_access_names[access]; } -const char *snd_pcm_format_name(snd_pcm_format_t format) -{ - snd_assert(format <= SNDRV_PCM_FORMAT_LAST, return NULL); - return snd_pcm_format_names[format]; -} - static const char *snd_pcm_subformat_name(snd_pcm_subformat_t subformat) { - snd_assert(subformat <= SNDRV_PCM_SUBFORMAT_LAST, return NULL); return snd_pcm_subformat_names[subformat]; } -static const char *snd_pcm_tstamp_mode_name(snd_pcm_tstamp_t mode) +static const char *snd_pcm_tstamp_mode_name(int mode) { snd_assert(mode <= SNDRV_PCM_TSTAMP_LAST, return NULL); return snd_pcm_tstamp_mode_names[mode]; @@ -232,7 +255,6 @@ static const char *snd_pcm_tstamp_mode_name(snd_pcm_tstamp_t mode) static const char *snd_pcm_state_name(snd_pcm_state_t state) { - snd_assert(state <= SNDRV_PCM_STATE_LAST, return NULL); return snd_pcm_state_names[state]; } @@ -267,10 +289,10 @@ static const char *snd_pcm_oss_format_name(int format) } #endif -#ifdef CONFIG_PROC_FS -static void snd_pcm_proc_info_read(snd_pcm_substream_t *substream, snd_info_buffer_t *buffer) +static void snd_pcm_proc_info_read(struct snd_pcm_substream *substream, + struct snd_info_buffer *buffer) { - snd_pcm_info_t *info; + struct snd_pcm_info *info; int err; if (! substream) @@ -302,20 +324,25 @@ static void snd_pcm_proc_info_read(snd_pcm_substream_t *substream, snd_info_buff kfree(info); } -static void snd_pcm_stream_proc_info_read(snd_info_entry_t *entry, snd_info_buffer_t *buffer) +static void snd_pcm_stream_proc_info_read(struct snd_info_entry *entry, + struct snd_info_buffer *buffer) { - snd_pcm_proc_info_read(((snd_pcm_str_t *)entry->private_data)->substream, buffer); + snd_pcm_proc_info_read(((struct snd_pcm_str *)entry->private_data)->substream, + buffer); } -static void snd_pcm_substream_proc_info_read(snd_info_entry_t *entry, snd_info_buffer_t *buffer) +static void snd_pcm_substream_proc_info_read(struct snd_info_entry *entry, + struct snd_info_buffer *buffer) { - snd_pcm_proc_info_read((snd_pcm_substream_t *)entry->private_data, buffer); + snd_pcm_proc_info_read((struct snd_pcm_substream *)entry->private_data, + buffer); } -static void snd_pcm_substream_proc_hw_params_read(snd_info_entry_t *entry, snd_info_buffer_t *buffer) +static void snd_pcm_substream_proc_hw_params_read(struct snd_info_entry *entry, + struct snd_info_buffer *buffer) { - snd_pcm_substream_t *substream = (snd_pcm_substream_t *)entry->private_data; - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_substream *substream = entry->private_data; + struct snd_pcm_runtime *runtime = substream->runtime; if (!runtime) { snd_iprintf(buffer, "closed\n"); return; @@ -347,10 +374,11 @@ static void snd_pcm_substream_proc_hw_params_read(snd_info_entry_t *entry, snd_i snd_pcm_stream_unlock_irq(substream); } -static void snd_pcm_substream_proc_sw_params_read(snd_info_entry_t *entry, snd_info_buffer_t *buffer) +static void snd_pcm_substream_proc_sw_params_read(struct snd_info_entry *entry, + struct snd_info_buffer *buffer) { - snd_pcm_substream_t *substream = (snd_pcm_substream_t *)entry->private_data; - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_substream *substream = entry->private_data; + struct snd_pcm_runtime *runtime = substream->runtime; if (!runtime) { snd_iprintf(buffer, "closed\n"); return; @@ -374,11 +402,12 @@ static void snd_pcm_substream_proc_sw_params_read(snd_info_entry_t *entry, snd_i snd_pcm_stream_unlock_irq(substream); } -static void snd_pcm_substream_proc_status_read(snd_info_entry_t *entry, snd_info_buffer_t *buffer) +static void snd_pcm_substream_proc_status_read(struct snd_info_entry *entry, + struct snd_info_buffer *buffer) { - snd_pcm_substream_t *substream = (snd_pcm_substream_t *)entry->private_data; - snd_pcm_runtime_t *runtime = substream->runtime; - snd_pcm_status_t status; + struct snd_pcm_substream *substream = entry->private_data; + struct snd_pcm_runtime *runtime = substream->runtime; + struct snd_pcm_status status; int err; if (!runtime) { snd_iprintf(buffer, "closed\n"); @@ -402,28 +431,29 @@ static void snd_pcm_substream_proc_status_read(snd_info_entry_t *entry, snd_info snd_iprintf(buffer, "hw_ptr : %ld\n", runtime->status->hw_ptr); snd_iprintf(buffer, "appl_ptr : %ld\n", runtime->control->appl_ptr); } -#endif #ifdef CONFIG_SND_DEBUG -static void snd_pcm_xrun_debug_read(snd_info_entry_t *entry, snd_info_buffer_t *buffer) +static void snd_pcm_xrun_debug_read(struct snd_info_entry *entry, + struct snd_info_buffer *buffer) { - snd_pcm_str_t *pstr = (snd_pcm_str_t *)entry->private_data; + struct snd_pcm_str *pstr = entry->private_data; snd_iprintf(buffer, "%d\n", pstr->xrun_debug); } -static void snd_pcm_xrun_debug_write(snd_info_entry_t *entry, snd_info_buffer_t *buffer) +static void snd_pcm_xrun_debug_write(struct snd_info_entry *entry, + struct snd_info_buffer *buffer) { - snd_pcm_str_t *pstr = (snd_pcm_str_t *)entry->private_data; + struct snd_pcm_str *pstr = entry->private_data; char line[64]; if (!snd_info_get_line(buffer, line, sizeof(line))) pstr->xrun_debug = simple_strtoul(line, NULL, 10); } #endif -static int snd_pcm_stream_proc_init(snd_pcm_str_t *pstr) +static int snd_pcm_stream_proc_init(struct snd_pcm_str *pstr) { - snd_pcm_t *pcm = pstr->pcm; - snd_info_entry_t *entry; + struct snd_pcm *pcm = pstr->pcm; + struct snd_info_entry *entry; char name[16]; sprintf(name, "pcm%i%c", pcm->device, @@ -447,7 +477,8 @@ static int snd_pcm_stream_proc_init(snd_pcm_str_t *pstr) pstr->proc_info_entry = entry; #ifdef CONFIG_SND_DEBUG - if ((entry = snd_info_create_card_entry(pcm->card, "xrun_debug", pstr->proc_root)) != NULL) { + if ((entry = snd_info_create_card_entry(pcm->card, "xrun_debug", + pstr->proc_root)) != NULL) { entry->c.text.read_size = 64; entry->c.text.read = snd_pcm_xrun_debug_read; entry->c.text.write_size = 64; @@ -464,7 +495,7 @@ static int snd_pcm_stream_proc_init(snd_pcm_str_t *pstr) return 0; } -static int snd_pcm_stream_proc_done(snd_pcm_str_t *pstr) +static int snd_pcm_stream_proc_done(struct snd_pcm_str *pstr) { #ifdef CONFIG_SND_DEBUG if (pstr->proc_xrun_debug_entry) { @@ -483,10 +514,10 @@ static int snd_pcm_stream_proc_done(snd_pcm_str_t *pstr) return 0; } -static int snd_pcm_substream_proc_init(snd_pcm_substream_t *substream) +static int snd_pcm_substream_proc_init(struct snd_pcm_substream *substream) { - snd_info_entry_t *entry; - snd_card_t *card; + struct snd_info_entry *entry; + struct snd_card *card; char name[16]; card = substream->pcm->card; @@ -540,7 +571,7 @@ static int snd_pcm_substream_proc_init(snd_pcm_substream_t *substream) return 0; } -static int snd_pcm_substream_proc_done(snd_pcm_substream_t *substream) +static int snd_pcm_substream_proc_done(struct snd_pcm_substream *substream) { if (substream->proc_info_entry) { snd_info_unregister(substream->proc_info_entry); @@ -564,6 +595,12 @@ static int snd_pcm_substream_proc_done(snd_pcm_substream_t *substream) } return 0; } +#else /* !CONFIG_PROC_FS */ +static inline int snd_pcm_stream_proc_init(struct snd_pcm_str *pstr) { return 0; } +static inline int snd_pcm_stream_proc_done(struct snd_pcm_str *pstr) { return 0; } +static inline int snd_pcm_substream_proc_init(struct snd_pcm_substream *substream) { return 0; } +static inline int snd_pcm_substream_proc_done(struct snd_pcm_substream *substream) { return 0; } +#endif /* CONFIG_PROC_FS */ /** * snd_pcm_new_stream - create a new PCM stream @@ -578,11 +615,11 @@ static int snd_pcm_substream_proc_done(snd_pcm_substream_t *substream) * * Returns zero if successful, or a negative error code on failure. */ -int snd_pcm_new_stream(snd_pcm_t *pcm, int stream, int substream_count) +int snd_pcm_new_stream(struct snd_pcm *pcm, int stream, int substream_count) { int idx, err; - snd_pcm_str_t *pstr = &pcm->streams[stream]; - snd_pcm_substream_t *substream, *prev; + struct snd_pcm_str *pstr = &pcm->streams[stream]; + struct snd_pcm_substream *substream, *prev; #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE) init_MUTEX(&pstr->oss.setup_mutex); @@ -590,17 +627,20 @@ int snd_pcm_new_stream(snd_pcm_t *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) + if (err < 0) { + snd_printk(KERN_ERR "Error in snd_pcm_stream_proc_init\n"); return err; + } } prev = NULL; for (idx = 0, prev = NULL; idx < substream_count; idx++) { substream = kzalloc(sizeof(*substream), GFP_KERNEL); - if (substream == NULL) + if (substream == NULL) { + snd_printk(KERN_ERR "Cannot allocate PCM substream\n"); return -ENOMEM; + } substream->pcm = pcm; substream->pstr = pstr; substream->number = idx; @@ -613,6 +653,7 @@ int snd_pcm_new_stream(snd_pcm_t *pcm, int stream, int substream_count) prev->next = substream; err = snd_pcm_substream_proc_init(substream); if (err < 0) { + snd_printk(KERN_ERR "Error in snd_pcm_stream_proc_init\n"); kfree(substream); return err; } @@ -642,13 +683,13 @@ int snd_pcm_new_stream(snd_pcm_t *pcm, int stream, int substream_count) * * Returns zero if successful, or a negative error code on failure. */ -int snd_pcm_new(snd_card_t * card, char *id, int device, +int snd_pcm_new(struct snd_card *card, char *id, int device, int playback_count, int capture_count, - snd_pcm_t ** rpcm) + struct snd_pcm ** rpcm) { - snd_pcm_t *pcm; + struct snd_pcm *pcm; int err; - static snd_device_ops_t ops = { + static struct snd_device_ops ops = { .dev_free = snd_pcm_dev_free, .dev_register = snd_pcm_dev_register, .dev_disconnect = snd_pcm_dev_disconnect, @@ -659,13 +700,14 @@ int snd_pcm_new(snd_card_t * card, char *id, int device, *rpcm = NULL; snd_assert(card != NULL, return -ENXIO); pcm = kzalloc(sizeof(*pcm), GFP_KERNEL); - if (pcm == NULL) + if (pcm == NULL) { + snd_printk(KERN_ERR "Cannot allocate PCM\n"); return -ENOMEM; + } pcm->card = card; pcm->device = device; - if (id) { + if (id) strlcpy(pcm->id, id, sizeof(pcm->id)); - } if ((err = snd_pcm_new_stream(pcm, SNDRV_PCM_STREAM_PLAYBACK, playback_count)) < 0) { snd_pcm_free(pcm); return err; @@ -684,11 +726,11 @@ int snd_pcm_new(snd_card_t * card, char *id, int device, return 0; } -static void snd_pcm_free_stream(snd_pcm_str_t * pstr) +static void snd_pcm_free_stream(struct snd_pcm_str * pstr) { - snd_pcm_substream_t *substream, *substream_next; + struct snd_pcm_substream *substream, *substream_next; #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE) - snd_pcm_oss_setup_t *setup, *setupn; + struct snd_pcm_oss_setup *setup, *setupn; #endif substream = pstr->substream; while (substream) { @@ -707,7 +749,7 @@ static void snd_pcm_free_stream(snd_pcm_str_t * pstr) #endif } -static int snd_pcm_free(snd_pcm_t *pcm) +static int snd_pcm_free(struct snd_pcm *pcm) { snd_assert(pcm != NULL, return -ENXIO); if (pcm->private_free) @@ -719,26 +761,26 @@ static int snd_pcm_free(snd_pcm_t *pcm) return 0; } -static int snd_pcm_dev_free(snd_device_t *device) +static int snd_pcm_dev_free(struct snd_device *device) { - snd_pcm_t *pcm = device->device_data; + struct snd_pcm *pcm = device->device_data; return snd_pcm_free(pcm); } static void snd_pcm_tick_timer_func(unsigned long data) { - snd_pcm_substream_t *substream = (snd_pcm_substream_t*) data; + struct snd_pcm_substream *substream = (struct snd_pcm_substream *) data; snd_pcm_tick_elapsed(substream); } -int snd_pcm_open_substream(snd_pcm_t *pcm, int stream, - snd_pcm_substream_t **rsubstream) +int snd_pcm_open_substream(struct snd_pcm *pcm, int stream, + struct snd_pcm_substream **rsubstream) { - snd_pcm_str_t * pstr; - snd_pcm_substream_t * substream; - snd_pcm_runtime_t * runtime; - snd_ctl_file_t *kctl; - snd_card_t *card; + struct snd_pcm_str * pstr; + struct snd_pcm_substream *substream; + struct snd_pcm_runtime *runtime; + struct snd_ctl_file *kctl; + struct snd_card *card; struct list_head *list; int prefer_subdevice = -1; size_t size; @@ -800,7 +842,7 @@ int snd_pcm_open_substream(snd_pcm_t *pcm, int stream, if (runtime == NULL) return -ENOMEM; - size = PAGE_ALIGN(sizeof(snd_pcm_mmap_status_t)); + size = PAGE_ALIGN(sizeof(struct snd_pcm_mmap_status)); runtime->status = snd_malloc_pages(size, GFP_KERNEL); if (runtime->status == NULL) { kfree(runtime); @@ -808,10 +850,11 @@ int snd_pcm_open_substream(snd_pcm_t *pcm, int stream, } memset((void*)runtime->status, 0, size); - size = PAGE_ALIGN(sizeof(snd_pcm_mmap_control_t)); + size = PAGE_ALIGN(sizeof(struct snd_pcm_mmap_control)); runtime->control = snd_malloc_pages(size, GFP_KERNEL); if (runtime->control == NULL) { - snd_free_pages((void*)runtime->status, PAGE_ALIGN(sizeof(snd_pcm_mmap_status_t))); + snd_free_pages((void*)runtime->status, + PAGE_ALIGN(sizeof(struct snd_pcm_mmap_status))); kfree(runtime); return -ENOMEM; } @@ -832,39 +875,39 @@ int snd_pcm_open_substream(snd_pcm_t *pcm, int stream, return 0; } -void snd_pcm_release_substream(snd_pcm_substream_t *substream) +void snd_pcm_release_substream(struct snd_pcm_substream *substream) { - snd_pcm_runtime_t * runtime; + struct snd_pcm_runtime *runtime; substream->file = NULL; runtime = substream->runtime; snd_assert(runtime != NULL, return); if (runtime->private_free != NULL) runtime->private_free(runtime); - snd_free_pages((void*)runtime->status, PAGE_ALIGN(sizeof(snd_pcm_mmap_status_t))); - snd_free_pages((void*)runtime->control, PAGE_ALIGN(sizeof(snd_pcm_mmap_control_t))); + snd_free_pages((void*)runtime->status, + PAGE_ALIGN(sizeof(struct snd_pcm_mmap_status))); + snd_free_pages((void*)runtime->control, + PAGE_ALIGN(sizeof(struct snd_pcm_mmap_control))); kfree(runtime->hw_constraints.rules); kfree(runtime); substream->runtime = NULL; substream->pstr->substream_opened--; } -static int snd_pcm_dev_register(snd_device_t *device) +static int snd_pcm_dev_register(struct snd_device *device) { - int idx, cidx, err; - unsigned short minor; - snd_pcm_substream_t *substream; + int cidx, err; + struct snd_pcm_substream *substream; struct list_head *list; char str[16]; - snd_pcm_t *pcm = device->device_data; + struct snd_pcm *pcm = device->device_data; snd_assert(pcm != NULL && device != NULL, return -ENXIO); down(®ister_mutex); - 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) @@ -872,17 +915,19 @@ static int snd_pcm_dev_register(snd_device_t *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, pcm->streams[cidx].reg, str)) < 0) { - snd_pcm_devices[idx] = NULL; + if ((err = snd_register_device(devtype, pcm->card, + pcm->device, + &snd_pcm_f_ops[cidx], + pcm, str)) < 0) + { + list_del(&pcm->list); up(®ister_mutex); return err; } @@ -890,48 +935,46 @@ static int snd_pcm_dev_register(snd_device_t *device) snd_pcm_timer_init(substream); } list_for_each(list, &snd_pcm_notify_list) { - snd_pcm_notify_t *notify; - notify = list_entry(list, snd_pcm_notify_t, list); + struct snd_pcm_notify *notify; + notify = list_entry(list, struct snd_pcm_notify, list); notify->n_register(pcm); } up(®ister_mutex); return 0; } -static int snd_pcm_dev_disconnect(snd_device_t *device) +static int snd_pcm_dev_disconnect(struct snd_device *device) { - snd_pcm_t *pcm = device->device_data; + struct snd_pcm *pcm = device->device_data; struct list_head *list; - snd_pcm_substream_t *substream; - int idx, cidx; + struct snd_pcm_substream *substream; + 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) substream->runtime->status->state = SNDRV_PCM_STATE_DISCONNECTED; list_for_each(list, &snd_pcm_notify_list) { - snd_pcm_notify_t *notify; - notify = list_entry(list, snd_pcm_notify_t, list); + struct snd_pcm_notify *notify; + notify = list_entry(list, struct snd_pcm_notify, list); notify->n_disconnect(pcm); } up(®ister_mutex); return 0; } -static int snd_pcm_dev_unregister(snd_device_t *device) +static int snd_pcm_dev_unregister(struct snd_device *device) { - int idx, cidx, devtype; - snd_pcm_substream_t *substream; + int cidx, devtype; + struct snd_pcm_substream *substream; struct list_head *list; - snd_pcm_t *pcm = device->device_data; + struct snd_pcm *pcm = device->device_data; snd_assert(pcm != NULL, return -ENXIO); down(®ister_mutex); - 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) { @@ -947,84 +990,99 @@ static int snd_pcm_dev_unregister(snd_device_t *device) snd_pcm_timer_done(substream); } list_for_each(list, &snd_pcm_notify_list) { - snd_pcm_notify_t *notify; - notify = list_entry(list, snd_pcm_notify_t, list); + struct snd_pcm_notify *notify; + notify = list_entry(list, struct snd_pcm_notify, list); notify->n_unregister(pcm); } up(®ister_mutex); return snd_pcm_free(pcm); } -int snd_pcm_notify(snd_pcm_notify_t *notify, int nfree) +int snd_pcm_notify(struct snd_pcm_notify *notify, int nfree) { - int idx; + 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; } +#ifdef CONFIG_PROC_FS /* * Info interface */ -static void snd_pcm_proc_read(snd_info_entry_t *entry, snd_info_buffer_t * buffer) +static void snd_pcm_proc_read(struct snd_info_entry *entry, + struct snd_info_buffer *buffer) { - int idx; - snd_pcm_t *pcm; + struct 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); + snd_iprintf(buffer, " : playback %i", + pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream_count); if (pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream) - snd_iprintf(buffer, " : capture %i", pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream_count); + snd_iprintf(buffer, " : capture %i", + pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream_count); snd_iprintf(buffer, "\n"); } up(®ister_mutex); } -/* - * ENTRY functions - */ - -static snd_info_entry_t *snd_pcm_proc_entry = NULL; +static struct snd_info_entry *snd_pcm_proc_entry = NULL; -static int __init alsa_pcm_init(void) +static void snd_pcm_proc_init(void) { - snd_info_entry_t *entry; + struct snd_info_entry *entry; - snd_ctl_register_ioctl(snd_pcm_control_ioctl); - snd_ctl_register_ioctl_compat(snd_pcm_control_ioctl); if ((entry = snd_info_create_module_entry(THIS_MODULE, "pcm", NULL)) != NULL) { - snd_info_set_text_ops(entry, NULL, SNDRV_CARDS * SNDRV_PCM_DEVICES * 128, snd_pcm_proc_read); + snd_info_set_text_ops(entry, NULL, SNDRV_CARDS * SNDRV_PCM_DEVICES * 128, + snd_pcm_proc_read); if (snd_info_register(entry) < 0) { snd_info_free_entry(entry); entry = NULL; } } snd_pcm_proc_entry = entry; +} + +static void snd_pcm_proc_done(void) +{ + if (snd_pcm_proc_entry) + snd_info_unregister(snd_pcm_proc_entry); +} + +#else /* !CONFIG_PROC_FS */ +#define snd_pcm_proc_init() +#define snd_pcm_proc_done() +#endif /* CONFIG_PROC_FS */ + + +/* + * ENTRY functions + */ + +static int __init alsa_pcm_init(void) +{ + snd_ctl_register_ioctl(snd_pcm_control_ioctl); + snd_ctl_register_ioctl_compat(snd_pcm_control_ioctl); + snd_pcm_proc_init(); return 0; } @@ -1032,16 +1090,12 @@ static void __exit alsa_pcm_exit(void) { snd_ctl_unregister_ioctl(snd_pcm_control_ioctl); snd_ctl_unregister_ioctl_compat(snd_pcm_control_ioctl); - if (snd_pcm_proc_entry) { - snd_info_unregister(snd_pcm_proc_entry); - snd_pcm_proc_entry = NULL; - } + snd_pcm_proc_done(); } 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_compat.c b/sound/core/pcm_compat.c index 4b6307df846..e5133033de5 100644 --- a/sound/core/pcm_compat.c +++ b/sound/core/pcm_compat.c @@ -22,7 +22,7 @@ #include <linux/compat.h> -static int snd_pcm_ioctl_delay_compat(snd_pcm_substream_t *substream, +static int snd_pcm_ioctl_delay_compat(struct snd_pcm_substream *substream, s32 __user *src) { snd_pcm_sframes_t delay; @@ -39,7 +39,7 @@ static int snd_pcm_ioctl_delay_compat(snd_pcm_substream_t *substream, return err; } -static int snd_pcm_ioctl_rewind_compat(snd_pcm_substream_t *substream, +static int snd_pcm_ioctl_rewind_compat(struct snd_pcm_substream *substream, u32 __user *src) { snd_pcm_uframes_t frames; @@ -56,7 +56,7 @@ static int snd_pcm_ioctl_rewind_compat(snd_pcm_substream_t *substream, return err < 0 ? err : 0; } -static int snd_pcm_ioctl_forward_compat(snd_pcm_substream_t *substream, +static int snd_pcm_ioctl_forward_compat(struct snd_pcm_substream *substream, u32 __user *src) { snd_pcm_uframes_t frames; @@ -73,12 +73,12 @@ static int snd_pcm_ioctl_forward_compat(snd_pcm_substream_t *substream, return err < 0 ? err : 0; } -struct sndrv_pcm_hw_params32 { +struct snd_pcm_hw_params32 { u32 flags; - struct sndrv_mask masks[SNDRV_PCM_HW_PARAM_LAST_MASK - SNDRV_PCM_HW_PARAM_FIRST_MASK + 1]; /* this must be identical */ - struct sndrv_mask mres[5]; /* reserved masks */ - struct sndrv_interval intervals[SNDRV_PCM_HW_PARAM_LAST_INTERVAL - SNDRV_PCM_HW_PARAM_FIRST_INTERVAL + 1]; - struct sndrv_interval ires[9]; /* reserved intervals */ + struct snd_mask masks[SNDRV_PCM_HW_PARAM_LAST_MASK - SNDRV_PCM_HW_PARAM_FIRST_MASK + 1]; /* this must be identical */ + struct snd_mask mres[5]; /* reserved masks */ + struct snd_interval intervals[SNDRV_PCM_HW_PARAM_LAST_INTERVAL - SNDRV_PCM_HW_PARAM_FIRST_INTERVAL + 1]; + struct snd_interval ires[9]; /* reserved intervals */ u32 rmask; u32 cmask; u32 info; @@ -89,7 +89,7 @@ struct sndrv_pcm_hw_params32 { unsigned char reserved[64]; }; -struct sndrv_pcm_sw_params32 { +struct snd_pcm_sw_params32 { s32 tstamp_mode; u32 period_step; u32 sleep_min; @@ -104,7 +104,7 @@ struct sndrv_pcm_sw_params32 { }; /* recalcuate the boundary within 32bit */ -static snd_pcm_uframes_t recalculate_boundary(snd_pcm_runtime_t *runtime) +static snd_pcm_uframes_t recalculate_boundary(struct snd_pcm_runtime *runtime) { snd_pcm_uframes_t boundary; @@ -116,10 +116,10 @@ static snd_pcm_uframes_t recalculate_boundary(snd_pcm_runtime_t *runtime) return boundary; } -static int snd_pcm_ioctl_sw_params_compat(snd_pcm_substream_t *substream, - struct sndrv_pcm_sw_params32 __user *src) +static int snd_pcm_ioctl_sw_params_compat(struct snd_pcm_substream *substream, + struct snd_pcm_sw_params32 __user *src) { - snd_pcm_sw_params_t params; + struct snd_pcm_sw_params params; snd_pcm_uframes_t boundary; int err; @@ -149,17 +149,17 @@ static int snd_pcm_ioctl_sw_params_compat(snd_pcm_substream_t *substream, return err; } -struct sndrv_pcm_channel_info32 { +struct snd_pcm_channel_info32 { u32 channel; u32 offset; u32 first; u32 step; }; -static int snd_pcm_ioctl_channel_info_compat(snd_pcm_substream_t *substream, - struct sndrv_pcm_channel_info32 __user *src) +static int snd_pcm_ioctl_channel_info_compat(struct snd_pcm_substream *substream, + struct snd_pcm_channel_info32 __user *src) { - snd_pcm_channel_info_t info; + struct snd_pcm_channel_info info; int err; if (get_user(info.channel, &src->channel) || @@ -178,7 +178,7 @@ static int snd_pcm_ioctl_channel_info_compat(snd_pcm_substream_t *substream, return err; } -struct sndrv_pcm_status32 { +struct snd_pcm_status32 { s32 state; struct compat_timespec trigger_tstamp; struct compat_timespec tstamp; @@ -193,10 +193,10 @@ struct sndrv_pcm_status32 { } __attribute__((packed)); -static int snd_pcm_status_user_compat(snd_pcm_substream_t *substream, - struct sndrv_pcm_status32 __user *src) +static int snd_pcm_status_user_compat(struct snd_pcm_substream *substream, + struct snd_pcm_status32 __user *src) { - snd_pcm_status_t status; + struct snd_pcm_status status; int err; err = snd_pcm_status(substream, &status); @@ -221,12 +221,12 @@ static int snd_pcm_status_user_compat(snd_pcm_substream_t *substream, } /* both for HW_PARAMS and HW_REFINE */ -static int snd_pcm_ioctl_hw_params_compat(snd_pcm_substream_t *substream, +static int snd_pcm_ioctl_hw_params_compat(struct snd_pcm_substream *substream, int refine, - struct sndrv_pcm_hw_params32 __user *data32) + struct snd_pcm_hw_params32 __user *data32) { - struct sndrv_pcm_hw_params *data; - snd_pcm_runtime_t *runtime; + struct snd_pcm_hw_params *data; + struct snd_pcm_runtime *runtime; int err; if (! (runtime = substream->runtime)) @@ -265,14 +265,14 @@ static int snd_pcm_ioctl_hw_params_compat(snd_pcm_substream_t *substream, /* */ -struct sndrv_xferi32 { +struct snd_xferi32 { s32 result; u32 buf; u32 frames; }; -static int snd_pcm_ioctl_xferi_compat(snd_pcm_substream_t *substream, - int dir, struct sndrv_xferi32 __user *data32) +static int snd_pcm_ioctl_xferi_compat(struct snd_pcm_substream *substream, + int dir, struct snd_xferi32 __user *data32) { compat_caddr_t buf; u32 frames; @@ -303,7 +303,7 @@ static int snd_pcm_ioctl_xferi_compat(snd_pcm_substream_t *substream, /* snd_xfern needs remapping of bufs */ -struct sndrv_xfern32 { +struct snd_xfern32 { s32 result; u32 bufs; /* this is void **; */ u32 frames; @@ -315,8 +315,8 @@ struct sndrv_xfern32 { * handler there expands again the same 128 pointers on stack, so it is better * to handle the function (calling pcm_readv/writev) directly in this handler. */ -static int snd_pcm_ioctl_xfern_compat(snd_pcm_substream_t *substream, - int dir, struct sndrv_xfern32 __user *data32) +static int snd_pcm_ioctl_xfern_compat(struct snd_pcm_substream *substream, + int dir, struct snd_xfern32 __user *data32) { compat_caddr_t buf; compat_caddr_t __user *bufptr; @@ -360,7 +360,7 @@ static int snd_pcm_ioctl_xfern_compat(snd_pcm_substream_t *substream, } -struct sndrv_pcm_mmap_status32 { +struct snd_pcm_mmap_status32 { s32 state; s32 pad1; u32 hw_ptr; @@ -368,32 +368,32 @@ struct sndrv_pcm_mmap_status32 { s32 suspended_state; } __attribute__((packed)); -struct sndrv_pcm_mmap_control32 { +struct snd_pcm_mmap_control32 { u32 appl_ptr; u32 avail_min; }; -struct sndrv_pcm_sync_ptr32 { +struct snd_pcm_sync_ptr32 { u32 flags; union { - struct sndrv_pcm_mmap_status32 status; + struct snd_pcm_mmap_status32 status; unsigned char reserved[64]; } s; union { - struct sndrv_pcm_mmap_control32 control; + struct snd_pcm_mmap_control32 control; unsigned char reserved[64]; } c; } __attribute__((packed)); -static int snd_pcm_ioctl_sync_ptr_compat(snd_pcm_substream_t *substream, - struct sndrv_pcm_sync_ptr32 __user *src) +static int snd_pcm_ioctl_sync_ptr_compat(struct snd_pcm_substream *substream, + struct snd_pcm_sync_ptr32 __user *src) { - snd_pcm_runtime_t *runtime = substream->runtime; - volatile struct sndrv_pcm_mmap_status *status; - volatile struct sndrv_pcm_mmap_control *control; + struct snd_pcm_runtime *runtime = substream->runtime; + volatile struct snd_pcm_mmap_status *status; + volatile struct snd_pcm_mmap_control *control; u32 sflags; - struct sndrv_pcm_mmap_control scontrol; - struct sndrv_pcm_mmap_status sstatus; + struct snd_pcm_mmap_control scontrol; + struct snd_pcm_mmap_status sstatus; snd_pcm_uframes_t boundary; int err; @@ -444,26 +444,26 @@ static int snd_pcm_ioctl_sync_ptr_compat(snd_pcm_substream_t *substream, /* */ enum { - SNDRV_PCM_IOCTL_HW_REFINE32 = _IOWR('A', 0x10, struct sndrv_pcm_hw_params32), - SNDRV_PCM_IOCTL_HW_PARAMS32 = _IOWR('A', 0x11, struct sndrv_pcm_hw_params32), - SNDRV_PCM_IOCTL_SW_PARAMS32 = _IOWR('A', 0x13, struct sndrv_pcm_sw_params32), - SNDRV_PCM_IOCTL_STATUS32 = _IOR('A', 0x20, struct sndrv_pcm_status32), + SNDRV_PCM_IOCTL_HW_REFINE32 = _IOWR('A', 0x10, struct snd_pcm_hw_params32), + SNDRV_PCM_IOCTL_HW_PARAMS32 = _IOWR('A', 0x11, struct snd_pcm_hw_params32), + SNDRV_PCM_IOCTL_SW_PARAMS32 = _IOWR('A', 0x13, struct snd_pcm_sw_params32), + SNDRV_PCM_IOCTL_STATUS32 = _IOR('A', 0x20, struct snd_pcm_status32), SNDRV_PCM_IOCTL_DELAY32 = _IOR('A', 0x21, s32), - SNDRV_PCM_IOCTL_CHANNEL_INFO32 = _IOR('A', 0x32, struct sndrv_pcm_channel_info32), + SNDRV_PCM_IOCTL_CHANNEL_INFO32 = _IOR('A', 0x32, struct snd_pcm_channel_info32), SNDRV_PCM_IOCTL_REWIND32 = _IOW('A', 0x46, u32), SNDRV_PCM_IOCTL_FORWARD32 = _IOW('A', 0x49, u32), - SNDRV_PCM_IOCTL_WRITEI_FRAMES32 = _IOW('A', 0x50, struct sndrv_xferi32), - SNDRV_PCM_IOCTL_READI_FRAMES32 = _IOR('A', 0x51, struct sndrv_xferi32), - SNDRV_PCM_IOCTL_WRITEN_FRAMES32 = _IOW('A', 0x52, struct sndrv_xfern32), - SNDRV_PCM_IOCTL_READN_FRAMES32 = _IOR('A', 0x53, struct sndrv_xfern32), - SNDRV_PCM_IOCTL_SYNC_PTR32 = _IOWR('A', 0x23, struct sndrv_pcm_sync_ptr32), + SNDRV_PCM_IOCTL_WRITEI_FRAMES32 = _IOW('A', 0x50, struct snd_xferi32), + SNDRV_PCM_IOCTL_READI_FRAMES32 = _IOR('A', 0x51, struct snd_xferi32), + SNDRV_PCM_IOCTL_WRITEN_FRAMES32 = _IOW('A', 0x52, struct snd_xfern32), + SNDRV_PCM_IOCTL_READN_FRAMES32 = _IOR('A', 0x53, struct snd_xfern32), + SNDRV_PCM_IOCTL_SYNC_PTR32 = _IOWR('A', 0x23, struct snd_pcm_sync_ptr32), }; static long snd_pcm_ioctl_compat(struct file *file, unsigned int cmd, unsigned long arg) { - snd_pcm_file_t *pcm_file; - snd_pcm_substream_t *substream; + struct snd_pcm_file *pcm_file; + struct snd_pcm_substream *substream; void __user *argp = compat_ptr(arg); pcm_file = file->private_data; diff --git a/sound/core/pcm_lib.c b/sound/core/pcm_lib.c index 3dbf9bf2ac1..eeba2f06095 100644 --- a/sound/core/pcm_lib.c +++ b/sound/core/pcm_lib.c @@ -39,9 +39,9 @@ * * when runtime->silence_size >= runtime->boundary - fill processed area with silence immediately */ -void snd_pcm_playback_silence(snd_pcm_substream_t *substream, snd_pcm_uframes_t new_hw_ptr) +void snd_pcm_playback_silence(struct snd_pcm_substream *substream, snd_pcm_uframes_t new_hw_ptr) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; snd_pcm_uframes_t frames, ofs, transfer; if (runtime->silence_size < runtime->boundary) { @@ -56,9 +56,8 @@ void snd_pcm_playback_silence(snd_pcm_substream_t *substream, snd_pcm_uframes_t runtime->silence_filled = 0; runtime->silence_start = runtime->control->appl_ptr; } - if (runtime->silence_filled == runtime->buffer_size) + if (runtime->silence_filled >= runtime->buffer_size) return; - snd_assert(runtime->silence_filled <= runtime->buffer_size, return); noise_dist = snd_pcm_playback_hw_avail(runtime) + runtime->silence_filled; if (noise_dist >= (snd_pcm_sframes_t) runtime->silence_threshold) return; @@ -128,7 +127,7 @@ void snd_pcm_playback_silence(snd_pcm_substream_t *substream, snd_pcm_uframes_t } } -static void xrun(snd_pcm_substream_t *substream) +static void xrun(struct snd_pcm_substream *substream) { snd_pcm_stop(substream, SNDRV_PCM_STATE_XRUN); #ifdef CONFIG_SND_DEBUG @@ -143,8 +142,8 @@ static void xrun(snd_pcm_substream_t *substream) #endif } -static inline snd_pcm_uframes_t snd_pcm_update_hw_ptr_pos(snd_pcm_substream_t *substream, - snd_pcm_runtime_t *runtime) +static inline snd_pcm_uframes_t snd_pcm_update_hw_ptr_pos(struct snd_pcm_substream *substream, + struct snd_pcm_runtime *runtime) { snd_pcm_uframes_t pos; @@ -162,8 +161,8 @@ static inline snd_pcm_uframes_t snd_pcm_update_hw_ptr_pos(snd_pcm_substream_t *s return pos; } -static inline int snd_pcm_update_hw_ptr_post(snd_pcm_substream_t *substream, - snd_pcm_runtime_t *runtime) +static inline int snd_pcm_update_hw_ptr_post(struct snd_pcm_substream *substream, + struct snd_pcm_runtime *runtime) { snd_pcm_uframes_t avail; @@ -185,9 +184,9 @@ static inline int snd_pcm_update_hw_ptr_post(snd_pcm_substream_t *substream, return 0; } -static inline int snd_pcm_update_hw_ptr_interrupt(snd_pcm_substream_t *substream) +static inline int snd_pcm_update_hw_ptr_interrupt(struct snd_pcm_substream *substream) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; snd_pcm_uframes_t pos; snd_pcm_uframes_t new_hw_ptr, hw_ptr_interrupt; snd_pcm_sframes_t delta; @@ -232,9 +231,9 @@ static inline int snd_pcm_update_hw_ptr_interrupt(snd_pcm_substream_t *substream } /* CAUTION: call it with irq disabled */ -int snd_pcm_update_hw_ptr(snd_pcm_substream_t *substream) +int snd_pcm_update_hw_ptr(struct snd_pcm_substream *substream) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; snd_pcm_uframes_t pos; snd_pcm_uframes_t old_hw_ptr, new_hw_ptr; snd_pcm_sframes_t delta; @@ -281,10 +280,10 @@ int snd_pcm_update_hw_ptr(snd_pcm_substream_t *substream) * * Sets the given PCM operators to the pcm instance. */ -void snd_pcm_set_ops(snd_pcm_t *pcm, int direction, snd_pcm_ops_t *ops) +void snd_pcm_set_ops(struct snd_pcm *pcm, int direction, struct snd_pcm_ops *ops) { - snd_pcm_str_t *stream = &pcm->streams[direction]; - snd_pcm_substream_t *substream; + struct snd_pcm_str *stream = &pcm->streams[direction]; + struct snd_pcm_substream *substream; for (substream = stream->substream; substream != NULL; substream = substream->next) substream->ops = ops; @@ -297,9 +296,9 @@ void snd_pcm_set_ops(snd_pcm_t *pcm, int direction, snd_pcm_ops_t *ops) * * Sets the PCM sync identifier for the card. */ -void snd_pcm_set_sync(snd_pcm_substream_t * substream) +void snd_pcm_set_sync(struct snd_pcm_substream *substream) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; runtime->sync.id32[0] = substream->pcm->card->number; runtime->sync.id32[1] = -1; @@ -370,7 +369,7 @@ static inline unsigned int muldiv32(unsigned int a, unsigned int b, return n; } -static int snd_interval_refine_min(snd_interval_t *i, unsigned int min, int openmin) +static int snd_interval_refine_min(struct snd_interval *i, unsigned int min, int openmin) { int changed = 0; assert(!snd_interval_empty(i)); @@ -395,7 +394,7 @@ static int snd_interval_refine_min(snd_interval_t *i, unsigned int min, int open return changed; } -static int snd_interval_refine_max(snd_interval_t *i, unsigned int max, int openmax) +static int snd_interval_refine_max(struct snd_interval *i, unsigned int max, int openmax) { int changed = 0; assert(!snd_interval_empty(i)); @@ -431,7 +430,7 @@ static int snd_interval_refine_max(snd_interval_t *i, unsigned int max, int open * * Returns non-zero if the value is changed, zero if not changed. */ -int snd_interval_refine(snd_interval_t *i, const snd_interval_t *v) +int snd_interval_refine(struct snd_interval *i, const struct snd_interval *v) { int changed = 0; assert(!snd_interval_empty(i)); @@ -473,7 +472,7 @@ int snd_interval_refine(snd_interval_t *i, const snd_interval_t *v) return changed; } -static int snd_interval_refine_first(snd_interval_t *i) +static int snd_interval_refine_first(struct snd_interval *i) { assert(!snd_interval_empty(i)); if (snd_interval_single(i)) @@ -485,7 +484,7 @@ static int snd_interval_refine_first(snd_interval_t *i) return 1; } -static int snd_interval_refine_last(snd_interval_t *i) +static int snd_interval_refine_last(struct snd_interval *i) { assert(!snd_interval_empty(i)); if (snd_interval_single(i)) @@ -497,9 +496,9 @@ static int snd_interval_refine_last(snd_interval_t *i) return 1; } -static int snd_interval_refine_set(snd_interval_t *i, unsigned int val) +static int snd_interval_refine_set(struct snd_interval *i, unsigned int val) { - snd_interval_t t; + struct snd_interval t; t.empty = 0; t.min = t.max = val; t.openmin = t.openmax = 0; @@ -507,7 +506,7 @@ static int snd_interval_refine_set(snd_interval_t *i, unsigned int val) return snd_interval_refine(i, &t); } -void snd_interval_mul(const snd_interval_t *a, const snd_interval_t *b, snd_interval_t *c) +void snd_interval_mul(const struct snd_interval *a, const struct snd_interval *b, struct snd_interval *c) { if (a->empty || b->empty) { snd_interval_none(c); @@ -531,7 +530,7 @@ void snd_interval_mul(const snd_interval_t *a, const snd_interval_t *b, snd_inte * * Returns non-zero if the value is changed, zero if not changed. */ -void snd_interval_div(const snd_interval_t *a, const snd_interval_t *b, snd_interval_t *c) +void snd_interval_div(const struct snd_interval *a, const struct snd_interval *b, struct snd_interval *c) { unsigned int r; if (a->empty || b->empty) { @@ -566,8 +565,8 @@ void snd_interval_div(const snd_interval_t *a, const snd_interval_t *b, snd_inte * * Returns non-zero if the value is changed, zero if not changed. */ -void snd_interval_muldivk(const snd_interval_t *a, const snd_interval_t *b, - unsigned int k, snd_interval_t *c) +void snd_interval_muldivk(const struct snd_interval *a, const struct snd_interval *b, + unsigned int k, struct snd_interval *c) { unsigned int r; if (a->empty || b->empty) { @@ -597,8 +596,8 @@ void snd_interval_muldivk(const snd_interval_t *a, const snd_interval_t *b, * * Returns non-zero if the value is changed, zero if not changed. */ -void snd_interval_mulkdiv(const snd_interval_t *a, unsigned int k, - const snd_interval_t *b, snd_interval_t *c) +void snd_interval_mulkdiv(const struct snd_interval *a, unsigned int k, + const struct snd_interval *b, struct snd_interval *c) { unsigned int r; if (a->empty || b->empty) { @@ -636,13 +635,13 @@ void snd_interval_mulkdiv(const snd_interval_t *a, unsigned int k, * * Returns non-zero if the value is changed, zero if not changed. */ -int snd_interval_ratnum(snd_interval_t *i, - unsigned int rats_count, ratnum_t *rats, - unsigned int *nump, unsigned int *denp) +int snd_interval_ratnum(struct snd_interval *i, + unsigned int rats_count, struct snd_ratnum *rats, + unsigned int *nump, unsigned int *denp) { unsigned int best_num, best_diff, best_den; unsigned int k; - snd_interval_t t; + struct snd_interval t; int err; best_num = best_den = best_diff = 0; @@ -731,20 +730,20 @@ int snd_interval_ratnum(snd_interval_t *i, /** * snd_interval_ratden - refine the interval value * @i: interval to refine - * @rats_count: number of ratden_t - * @rats: ratden_t array + * @rats_count: number of struct ratden + * @rats: struct ratden array * @nump: pointer to store the resultant numerator * @denp: pointer to store the resultant denominator * * Returns non-zero if the value is changed, zero if not changed. */ -static int snd_interval_ratden(snd_interval_t *i, - unsigned int rats_count, ratden_t *rats, +static int snd_interval_ratden(struct snd_interval *i, + unsigned int rats_count, struct snd_ratden *rats, unsigned int *nump, unsigned int *denp) { unsigned int best_num, best_diff, best_den; unsigned int k; - snd_interval_t t; + struct snd_interval t; int err; best_num = best_den = best_diff = 0; @@ -837,7 +836,7 @@ static int snd_interval_ratden(snd_interval_t *i, * * Returns non-zero if the value is changed, zero if not changed. */ -int snd_interval_list(snd_interval_t *i, unsigned int count, unsigned int *list, unsigned int mask) +int snd_interval_list(struct snd_interval *i, unsigned int count, unsigned int *list, unsigned int mask) { unsigned int k; int changed = 0; @@ -878,7 +877,7 @@ int snd_interval_list(snd_interval_t *i, unsigned int count, unsigned int *list, return changed; } -static int snd_interval_step(snd_interval_t *i, unsigned int min, unsigned int step) +static int snd_interval_step(struct snd_interval *i, unsigned int min, unsigned int step) { unsigned int n; int changed = 0; @@ -912,18 +911,18 @@ static int snd_interval_step(snd_interval_t *i, unsigned int min, unsigned int s * * Returns zero if successful, or a negative error code on failure. */ -int snd_pcm_hw_rule_add(snd_pcm_runtime_t *runtime, unsigned int cond, +int snd_pcm_hw_rule_add(struct snd_pcm_runtime *runtime, unsigned int cond, int var, snd_pcm_hw_rule_func_t func, void *private, int dep, ...) { - snd_pcm_hw_constraints_t *constrs = &runtime->hw_constraints; - snd_pcm_hw_rule_t *c; + struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints; + struct snd_pcm_hw_rule *c; unsigned int k; va_list args; va_start(args, dep); if (constrs->rules_num >= constrs->rules_all) { - snd_pcm_hw_rule_t *new; + struct snd_pcm_hw_rule *new; unsigned int new_rules = constrs->rules_all + 16; new = kcalloc(new_rules, sizeof(*c), GFP_KERNEL); if (!new) @@ -962,11 +961,11 @@ int snd_pcm_hw_rule_add(snd_pcm_runtime_t *runtime, unsigned int cond, * * Apply the constraint of the given bitmap mask to a mask parameter. */ -int snd_pcm_hw_constraint_mask(snd_pcm_runtime_t *runtime, snd_pcm_hw_param_t var, +int snd_pcm_hw_constraint_mask(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var, u_int32_t mask) { - snd_pcm_hw_constraints_t *constrs = &runtime->hw_constraints; - snd_mask_t *maskp = constrs_mask(constrs, var); + struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints; + struct snd_mask *maskp = constrs_mask(constrs, var); *maskp->bits &= mask; memset(maskp->bits + 1, 0, (SNDRV_MASK_MAX-32) / 8); /* clear rest */ if (*maskp->bits == 0) @@ -982,11 +981,11 @@ int snd_pcm_hw_constraint_mask(snd_pcm_runtime_t *runtime, snd_pcm_hw_param_t va * * Apply the constraint of the given bitmap mask to a mask parameter. */ -int snd_pcm_hw_constraint_mask64(snd_pcm_runtime_t *runtime, snd_pcm_hw_param_t var, +int snd_pcm_hw_constraint_mask64(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var, u_int64_t mask) { - snd_pcm_hw_constraints_t *constrs = &runtime->hw_constraints; - snd_mask_t *maskp = constrs_mask(constrs, var); + struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints; + struct snd_mask *maskp = constrs_mask(constrs, var); maskp->bits[0] &= (u_int32_t)mask; maskp->bits[1] &= (u_int32_t)(mask >> 32); memset(maskp->bits + 2, 0, (SNDRV_MASK_MAX-64) / 8); /* clear rest */ @@ -1002,9 +1001,9 @@ int snd_pcm_hw_constraint_mask64(snd_pcm_runtime_t *runtime, snd_pcm_hw_param_t * * Apply the constraint of integer to an interval parameter. */ -int snd_pcm_hw_constraint_integer(snd_pcm_runtime_t *runtime, snd_pcm_hw_param_t var) +int snd_pcm_hw_constraint_integer(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var) { - snd_pcm_hw_constraints_t *constrs = &runtime->hw_constraints; + struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints; return snd_interval_setinteger(constrs_interval(constrs, var)); } @@ -1017,11 +1016,11 @@ int snd_pcm_hw_constraint_integer(snd_pcm_runtime_t *runtime, snd_pcm_hw_param_t * * Apply the min/max range constraint to an interval parameter. */ -int snd_pcm_hw_constraint_minmax(snd_pcm_runtime_t *runtime, snd_pcm_hw_param_t var, +int snd_pcm_hw_constraint_minmax(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var, unsigned int min, unsigned int max) { - snd_pcm_hw_constraints_t *constrs = &runtime->hw_constraints; - snd_interval_t t; + struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints; + struct snd_interval t; t.min = min; t.max = max; t.openmin = t.openmax = 0; @@ -1029,10 +1028,10 @@ int snd_pcm_hw_constraint_minmax(snd_pcm_runtime_t *runtime, snd_pcm_hw_param_t return snd_interval_refine(constrs_interval(constrs, var), &t); } -static int snd_pcm_hw_rule_list(snd_pcm_hw_params_t *params, - snd_pcm_hw_rule_t *rule) +static int snd_pcm_hw_rule_list(struct snd_pcm_hw_params *params, + struct snd_pcm_hw_rule *rule) { - snd_pcm_hw_constraint_list_t *list = rule->private; + struct snd_pcm_hw_constraint_list *list = rule->private; return snd_interval_list(hw_param_interval(params, rule->var), list->count, list->list, list->mask); } @@ -1046,20 +1045,20 @@ static int snd_pcm_hw_rule_list(snd_pcm_hw_params_t *params, * * Apply the list of constraints to an interval parameter. */ -int snd_pcm_hw_constraint_list(snd_pcm_runtime_t *runtime, +int snd_pcm_hw_constraint_list(struct snd_pcm_runtime *runtime, unsigned int cond, snd_pcm_hw_param_t var, - snd_pcm_hw_constraint_list_t *l) + struct snd_pcm_hw_constraint_list *l) { return snd_pcm_hw_rule_add(runtime, cond, var, snd_pcm_hw_rule_list, l, var, -1); } -static int snd_pcm_hw_rule_ratnums(snd_pcm_hw_params_t *params, - snd_pcm_hw_rule_t *rule) +static int snd_pcm_hw_rule_ratnums(struct snd_pcm_hw_params *params, + struct snd_pcm_hw_rule *rule) { - snd_pcm_hw_constraint_ratnums_t *r = rule->private; + struct snd_pcm_hw_constraint_ratnums *r = rule->private; unsigned int num = 0, den = 0; int err; err = snd_interval_ratnum(hw_param_interval(params, rule->var), @@ -1076,22 +1075,22 @@ static int snd_pcm_hw_rule_ratnums(snd_pcm_hw_params_t *params, * @runtime: PCM runtime instance * @cond: condition bits * @var: hw_params variable to apply the ratnums constraint - * @r: ratnums_t constriants + * @r: struct snd_ratnums constriants */ -int snd_pcm_hw_constraint_ratnums(snd_pcm_runtime_t *runtime, +int snd_pcm_hw_constraint_ratnums(struct snd_pcm_runtime *runtime, unsigned int cond, snd_pcm_hw_param_t var, - snd_pcm_hw_constraint_ratnums_t *r) + struct snd_pcm_hw_constraint_ratnums *r) { return snd_pcm_hw_rule_add(runtime, cond, var, snd_pcm_hw_rule_ratnums, r, var, -1); } -static int snd_pcm_hw_rule_ratdens(snd_pcm_hw_params_t *params, - snd_pcm_hw_rule_t *rule) +static int snd_pcm_hw_rule_ratdens(struct snd_pcm_hw_params *params, + struct snd_pcm_hw_rule *rule) { - snd_pcm_hw_constraint_ratdens_t *r = rule->private; + struct snd_pcm_hw_constraint_ratdens *r = rule->private; unsigned int num = 0, den = 0; int err = snd_interval_ratden(hw_param_interval(params, rule->var), r->nrats, r->rats, &num, &den); @@ -1107,25 +1106,25 @@ static int snd_pcm_hw_rule_ratdens(snd_pcm_hw_params_t *params, * @runtime: PCM runtime instance * @cond: condition bits * @var: hw_params variable to apply the ratdens constraint - * @r: ratdens_t constriants + * @r: struct snd_ratdens constriants */ -int snd_pcm_hw_constraint_ratdens(snd_pcm_runtime_t *runtime, +int snd_pcm_hw_constraint_ratdens(struct snd_pcm_runtime *runtime, unsigned int cond, snd_pcm_hw_param_t var, - snd_pcm_hw_constraint_ratdens_t *r) + struct snd_pcm_hw_constraint_ratdens *r) { return snd_pcm_hw_rule_add(runtime, cond, var, snd_pcm_hw_rule_ratdens, r, var, -1); } -static int snd_pcm_hw_rule_msbits(snd_pcm_hw_params_t *params, - snd_pcm_hw_rule_t *rule) +static int snd_pcm_hw_rule_msbits(struct snd_pcm_hw_params *params, + struct snd_pcm_hw_rule *rule) { unsigned int l = (unsigned long) rule->private; int width = l & 0xffff; unsigned int msbits = l >> 16; - snd_interval_t *i = hw_param_interval(params, SNDRV_PCM_HW_PARAM_SAMPLE_BITS); + struct snd_interval *i = hw_param_interval(params, SNDRV_PCM_HW_PARAM_SAMPLE_BITS); if (snd_interval_single(i) && snd_interval_value(i) == width) params->msbits = msbits; return 0; @@ -1138,7 +1137,7 @@ static int snd_pcm_hw_rule_msbits(snd_pcm_hw_params_t *params, * @width: sample bits width * @msbits: msbits width */ -int snd_pcm_hw_constraint_msbits(snd_pcm_runtime_t *runtime, +int snd_pcm_hw_constraint_msbits(struct snd_pcm_runtime *runtime, unsigned int cond, unsigned int width, unsigned int msbits) @@ -1150,8 +1149,8 @@ int snd_pcm_hw_constraint_msbits(snd_pcm_runtime_t *runtime, SNDRV_PCM_HW_PARAM_SAMPLE_BITS, -1); } -static int snd_pcm_hw_rule_step(snd_pcm_hw_params_t *params, - snd_pcm_hw_rule_t *rule) +static int snd_pcm_hw_rule_step(struct snd_pcm_hw_params *params, + struct snd_pcm_hw_rule *rule) { unsigned long step = (unsigned long) rule->private; return snd_interval_step(hw_param_interval(params, rule->var), 0, step); @@ -1164,7 +1163,7 @@ static int snd_pcm_hw_rule_step(snd_pcm_hw_params_t *params, * @var: hw_params variable to apply the step constraint * @step: step size */ -int snd_pcm_hw_constraint_step(snd_pcm_runtime_t *runtime, +int snd_pcm_hw_constraint_step(struct snd_pcm_runtime *runtime, unsigned int cond, snd_pcm_hw_param_t var, unsigned long step) @@ -1174,7 +1173,7 @@ int snd_pcm_hw_constraint_step(snd_pcm_runtime_t *runtime, var, -1); } -static int snd_pcm_hw_rule_pow2(snd_pcm_hw_params_t *params, snd_pcm_hw_rule_t *rule) +static int snd_pcm_hw_rule_pow2(struct snd_pcm_hw_params *params, struct snd_pcm_hw_rule *rule) { static int pow2_sizes[] = { 1<<0, 1<<1, 1<<2, 1<<3, 1<<4, 1<<5, 1<<6, 1<<7, @@ -1192,7 +1191,7 @@ static int snd_pcm_hw_rule_pow2(snd_pcm_hw_params_t *params, snd_pcm_hw_rule_t * * @cond: condition bits * @var: hw_params variable to apply the power-of-2 constraint */ -int snd_pcm_hw_constraint_pow2(snd_pcm_runtime_t *runtime, +int snd_pcm_hw_constraint_pow2(struct snd_pcm_runtime *runtime, unsigned int cond, snd_pcm_hw_param_t var) { @@ -1202,13 +1201,12 @@ int snd_pcm_hw_constraint_pow2(snd_pcm_runtime_t *runtime, } /* To use the same code we have in alsa-lib */ -#define snd_pcm_t snd_pcm_substream_t #define assert(i) snd_assert((i), return -EINVAL) #ifndef INT_MIN #define INT_MIN ((int)((unsigned int)INT_MAX+1)) #endif -static void _snd_pcm_hw_param_any(snd_pcm_hw_params_t *params, +static void _snd_pcm_hw_param_any(struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var) { if (hw_is_mask(var)) { @@ -1230,7 +1228,7 @@ static void _snd_pcm_hw_param_any(snd_pcm_hw_params_t *params, /* * snd_pcm_hw_param_any */ -int snd_pcm_hw_param_any(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, +int snd_pcm_hw_param_any(struct snd_pcm_substream *pcm, struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var) { _snd_pcm_hw_param_any(params, var); @@ -1238,7 +1236,7 @@ int snd_pcm_hw_param_any(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, } #endif /* 0 */ -void _snd_pcm_hw_params_any(snd_pcm_hw_params_t *params) +void _snd_pcm_hw_params_any(struct snd_pcm_hw_params *params) { unsigned int k; memset(params, 0, sizeof(*params)); @@ -1255,7 +1253,7 @@ void _snd_pcm_hw_params_any(snd_pcm_hw_params_t *params) * * Fill PARAMS with full configuration space boundaries */ -int snd_pcm_hw_params_any(snd_pcm_t *pcm, snd_pcm_hw_params_t *params) +int snd_pcm_hw_params_any(struct snd_pcm_substream *pcm, struct snd_pcm_hw_params *params) { _snd_pcm_hw_params_any(params); return snd_pcm_hw_refine(pcm, params); @@ -1271,11 +1269,11 @@ int snd_pcm_hw_params_any(snd_pcm_t *pcm, snd_pcm_hw_params_t *params) * Return the value for field PAR if it's fixed in configuration space * defined by PARAMS. Return -EINVAL otherwise */ -static int snd_pcm_hw_param_value(const snd_pcm_hw_params_t *params, +static int snd_pcm_hw_param_value(const struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var, int *dir) { if (hw_is_mask(var)) { - const snd_mask_t *mask = hw_param_mask_c(params, var); + const struct snd_mask *mask = hw_param_mask_c(params, var); if (!snd_mask_single(mask)) return -EINVAL; if (dir) @@ -1283,7 +1281,7 @@ static int snd_pcm_hw_param_value(const snd_pcm_hw_params_t *params, return snd_mask_value(mask); } if (hw_is_interval(var)) { - const snd_interval_t *i = hw_param_interval_c(params, var); + const struct snd_interval *i = hw_param_interval_c(params, var); if (!snd_interval_single(i)) return -EINVAL; if (dir) @@ -1302,7 +1300,7 @@ static int snd_pcm_hw_param_value(const snd_pcm_hw_params_t *params, * * Return the minimum value for field PAR. */ -unsigned int snd_pcm_hw_param_value_min(const snd_pcm_hw_params_t *params, +unsigned int snd_pcm_hw_param_value_min(const struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var, int *dir) { if (hw_is_mask(var)) { @@ -1311,7 +1309,7 @@ unsigned int snd_pcm_hw_param_value_min(const snd_pcm_hw_params_t *params, return snd_mask_min(hw_param_mask_c(params, var)); } if (hw_is_interval(var)) { - const snd_interval_t *i = hw_param_interval_c(params, var); + const struct snd_interval *i = hw_param_interval_c(params, var); if (dir) *dir = i->openmin; return snd_interval_min(i); @@ -1328,7 +1326,7 @@ unsigned int snd_pcm_hw_param_value_min(const snd_pcm_hw_params_t *params, * * Return the maximum value for field PAR. */ -unsigned int snd_pcm_hw_param_value_max(const snd_pcm_hw_params_t *params, +unsigned int snd_pcm_hw_param_value_max(const struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var, int *dir) { if (hw_is_mask(var)) { @@ -1337,7 +1335,7 @@ unsigned int snd_pcm_hw_param_value_max(const snd_pcm_hw_params_t *params, return snd_mask_max(hw_param_mask_c(params, var)); } if (hw_is_interval(var)) { - const snd_interval_t *i = hw_param_interval_c(params, var); + const struct snd_interval *i = hw_param_interval_c(params, var); if (dir) *dir = - (int) i->openmax; return snd_interval_max(i); @@ -1346,7 +1344,7 @@ unsigned int snd_pcm_hw_param_value_max(const snd_pcm_hw_params_t *params, return -EINVAL; } -void _snd_pcm_hw_param_setempty(snd_pcm_hw_params_t *params, +void _snd_pcm_hw_param_setempty(struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var) { if (hw_is_mask(var)) { @@ -1362,7 +1360,7 @@ void _snd_pcm_hw_param_setempty(snd_pcm_hw_params_t *params, } } -int _snd_pcm_hw_param_setinteger(snd_pcm_hw_params_t *params, +int _snd_pcm_hw_param_setinteger(struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var) { int changed; @@ -1383,8 +1381,8 @@ int _snd_pcm_hw_param_setinteger(snd_pcm_hw_params_t *params, * non integer values. Reduce configuration space accordingly. * Return -EINVAL if the configuration space is empty */ -int snd_pcm_hw_param_setinteger(snd_pcm_t *pcm, - snd_pcm_hw_params_t *params, +int snd_pcm_hw_param_setinteger(struct snd_pcm_substream *pcm, + struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var) { int changed = _snd_pcm_hw_param_setinteger(params, var); @@ -1399,7 +1397,7 @@ int snd_pcm_hw_param_setinteger(snd_pcm_t *pcm, } #endif /* 0 */ -static int _snd_pcm_hw_param_first(snd_pcm_hw_params_t *params, +static int _snd_pcm_hw_param_first(struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var) { int changed; @@ -1430,8 +1428,8 @@ static int _snd_pcm_hw_param_first(snd_pcm_hw_params_t *params, * values > minimum. Reduce configuration space accordingly. * Return the minimum. */ -static int snd_pcm_hw_param_first(snd_pcm_t *pcm, - snd_pcm_hw_params_t *params, +static int snd_pcm_hw_param_first(struct snd_pcm_substream *pcm, + struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var, int *dir) { int changed = _snd_pcm_hw_param_first(params, var); @@ -1444,7 +1442,7 @@ static int snd_pcm_hw_param_first(snd_pcm_t *pcm, return snd_pcm_hw_param_value(params, var, dir); } -static int _snd_pcm_hw_param_last(snd_pcm_hw_params_t *params, +static int _snd_pcm_hw_param_last(struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var) { int changed; @@ -1475,8 +1473,8 @@ static int _snd_pcm_hw_param_last(snd_pcm_hw_params_t *params, * values < maximum. Reduce configuration space accordingly. * Return the maximum. */ -static int snd_pcm_hw_param_last(snd_pcm_t *pcm, - snd_pcm_hw_params_t *params, +static int snd_pcm_hw_param_last(struct snd_pcm_substream *pcm, + struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var, int *dir) { int changed = _snd_pcm_hw_param_last(params, var); @@ -1489,7 +1487,7 @@ static int snd_pcm_hw_param_last(snd_pcm_t *pcm, return snd_pcm_hw_param_value(params, var, dir); } -int _snd_pcm_hw_param_min(snd_pcm_hw_params_t *params, +int _snd_pcm_hw_param_min(struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var, unsigned int val, int dir) { int changed; @@ -1531,7 +1529,7 @@ int _snd_pcm_hw_param_min(snd_pcm_hw_params_t *params, * values < VAL. Reduce configuration space accordingly. * Return new minimum or -EINVAL if the configuration space is empty */ -static int snd_pcm_hw_param_min(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, +static int snd_pcm_hw_param_min(struct snd_pcm_substream *pcm, struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var, unsigned int val, int *dir) { @@ -1546,7 +1544,7 @@ static int snd_pcm_hw_param_min(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, return snd_pcm_hw_param_value_min(params, var, dir); } -static int _snd_pcm_hw_param_max(snd_pcm_hw_params_t *params, +static int _snd_pcm_hw_param_max(struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var, unsigned int val, int dir) { @@ -1591,7 +1589,7 @@ static int _snd_pcm_hw_param_max(snd_pcm_hw_params_t *params, * values >= VAL + 1. Reduce configuration space accordingly. * Return new maximum or -EINVAL if the configuration space is empty */ -static int snd_pcm_hw_param_max(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, +static int snd_pcm_hw_param_max(struct snd_pcm_substream *pcm, struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var, unsigned int val, int *dir) { @@ -1606,12 +1604,12 @@ static int snd_pcm_hw_param_max(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, return snd_pcm_hw_param_value_max(params, var, dir); } -int _snd_pcm_hw_param_set(snd_pcm_hw_params_t *params, +int _snd_pcm_hw_param_set(struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var, unsigned int val, int dir) { int changed; if (hw_is_mask(var)) { - snd_mask_t *m = hw_param_mask(params, var); + struct snd_mask *m = hw_param_mask(params, var); if (val == 0 && dir < 0) { changed = -EINVAL; snd_mask_none(m); @@ -1623,14 +1621,14 @@ int _snd_pcm_hw_param_set(snd_pcm_hw_params_t *params, changed = snd_mask_refine_set(hw_param_mask(params, var), val); } } else if (hw_is_interval(var)) { - snd_interval_t *i = hw_param_interval(params, var); + struct snd_interval *i = hw_param_interval(params, var); if (val == 0 && dir < 0) { changed = -EINVAL; snd_interval_none(i); } else if (dir == 0) changed = snd_interval_refine_set(i, val); else { - snd_interval_t t; + struct snd_interval t; t.openmin = 1; t.openmax = 1; t.empty = 0; @@ -1667,7 +1665,7 @@ int _snd_pcm_hw_param_set(snd_pcm_hw_params_t *params, * values != VAL. Reduce configuration space accordingly. * Return VAL or -EINVAL if the configuration space is empty */ -int snd_pcm_hw_param_set(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, +int snd_pcm_hw_param_set(struct snd_pcm_substream *pcm, struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var, unsigned int val, int dir) { int changed = _snd_pcm_hw_param_set(params, var, val, dir); @@ -1681,8 +1679,8 @@ int snd_pcm_hw_param_set(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, return snd_pcm_hw_param_value(params, var, NULL); } -static int _snd_pcm_hw_param_mask(snd_pcm_hw_params_t *params, - snd_pcm_hw_param_t var, const snd_mask_t *val) +static int _snd_pcm_hw_param_mask(struct snd_pcm_hw_params *params, + snd_pcm_hw_param_t var, const struct snd_mask *val) { int changed; assert(hw_is_mask(var)); @@ -1708,8 +1706,8 @@ static int _snd_pcm_hw_param_mask(snd_pcm_hw_params_t *params, * Return 0 on success or -EINVAL * if the configuration space is empty */ -int snd_pcm_hw_param_mask(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, - snd_pcm_hw_param_t var, const snd_mask_t *val) +int snd_pcm_hw_param_mask(struct snd_pcm_substream *pcm, struct snd_pcm_hw_params *params, + snd_pcm_hw_param_t var, const struct snd_mask *val) { int changed = _snd_pcm_hw_param_mask(params, var, val); if (changed < 0) @@ -1784,10 +1782,10 @@ static int boundary_nearer(int min, int mindir, * SNDRV_PCM_HW_PARAM_FORMAT, SNDRV_PCM_HW_PARAM_SUBFORMAT. * Return the value found. */ -int snd_pcm_hw_param_near(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, +int snd_pcm_hw_param_near(struct snd_pcm_substream *pcm, struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var, unsigned int best, int *dir) { - snd_pcm_hw_params_t *save = NULL; + struct snd_pcm_hw_params *save = NULL; int v; unsigned int saved_min; int last = 0; @@ -1814,7 +1812,7 @@ int snd_pcm_hw_param_near(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, saved_min = min; min = snd_pcm_hw_param_min(pcm, params, var, min, &mindir); if (min >= 0) { - snd_pcm_hw_params_t *params1; + struct snd_pcm_hw_params *params1; if (max < 0) goto _end; if ((unsigned int)min == saved_min && mindir == valdir) @@ -1861,7 +1859,7 @@ int snd_pcm_hw_param_near(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, * first access, first format, first subformat, min channels, * min rate, min period time, max buffer size, min tick time */ -int snd_pcm_hw_params_choose(snd_pcm_t *pcm, snd_pcm_hw_params_t *params) +int snd_pcm_hw_params_choose(struct snd_pcm_substream *pcm, struct snd_pcm_hw_params *params) { int err; @@ -1892,13 +1890,12 @@ int snd_pcm_hw_params_choose(snd_pcm_t *pcm, snd_pcm_hw_params_t *params) return 0; } -#undef snd_pcm_t #undef assert -static int snd_pcm_lib_ioctl_reset(snd_pcm_substream_t *substream, +static int snd_pcm_lib_ioctl_reset(struct snd_pcm_substream *substream, void *arg) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; unsigned long flags; snd_pcm_stream_lock_irqsave(substream, flags); if (snd_pcm_running(substream) && @@ -1910,11 +1907,11 @@ static int snd_pcm_lib_ioctl_reset(snd_pcm_substream_t *substream, return 0; } -static int snd_pcm_lib_ioctl_channel_info(snd_pcm_substream_t *substream, +static int snd_pcm_lib_ioctl_channel_info(struct snd_pcm_substream *substream, void *arg) { - snd_pcm_channel_info_t *info = arg; - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_channel_info *info = arg; + struct snd_pcm_runtime *runtime = substream->runtime; int width; if (!(runtime->info & SNDRV_PCM_INFO_MMAP)) { info->offset = -1; @@ -1956,7 +1953,7 @@ static int snd_pcm_lib_ioctl_channel_info(snd_pcm_substream_t *substream, * * Returns zero if successful, or a negative error code on failure. */ -int snd_pcm_lib_ioctl(snd_pcm_substream_t *substream, +int snd_pcm_lib_ioctl(struct snd_pcm_substream *substream, unsigned int cmd, void *arg) { switch (cmd) { @@ -1974,10 +1971,10 @@ int snd_pcm_lib_ioctl(snd_pcm_substream_t *substream, * Conditions */ -static void snd_pcm_system_tick_set(snd_pcm_substream_t *substream, +static void snd_pcm_system_tick_set(struct snd_pcm_substream *substream, unsigned long ticks) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; if (ticks == 0) del_timer(&runtime->tick_timer); else { @@ -1988,14 +1985,14 @@ static void snd_pcm_system_tick_set(snd_pcm_substream_t *substream, } /* Temporary alias */ -void snd_pcm_tick_set(snd_pcm_substream_t *substream, unsigned long ticks) +void snd_pcm_tick_set(struct snd_pcm_substream *substream, unsigned long ticks) { snd_pcm_system_tick_set(substream, ticks); } -void snd_pcm_tick_prepare(snd_pcm_substream_t *substream) +void snd_pcm_tick_prepare(struct snd_pcm_substream *substream) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; snd_pcm_uframes_t frames = ULONG_MAX; snd_pcm_uframes_t avail, dist; unsigned int ticks; @@ -2008,8 +2005,8 @@ void snd_pcm_tick_prepare(snd_pcm_substream_t *substream) runtime->silence_filled < runtime->buffer_size) { snd_pcm_sframes_t noise_dist; noise_dist = snd_pcm_playback_hw_avail(runtime) + runtime->silence_filled; - snd_assert(noise_dist <= (snd_pcm_sframes_t)runtime->silence_threshold, ); - frames = noise_dist - runtime->silence_threshold; + if (noise_dist > (snd_pcm_sframes_t)runtime->silence_threshold) + frames = noise_dist - runtime->silence_threshold; } avail = snd_pcm_playback_avail(runtime); } else { @@ -2046,9 +2043,9 @@ void snd_pcm_tick_prepare(snd_pcm_substream_t *substream) snd_pcm_tick_set(substream, (unsigned long) ticks); } -void snd_pcm_tick_elapsed(snd_pcm_substream_t *substream) +void snd_pcm_tick_elapsed(struct snd_pcm_substream *substream) { - snd_pcm_runtime_t *runtime; + struct snd_pcm_runtime *runtime; unsigned long flags; snd_assert(substream != NULL, return); @@ -2076,9 +2073,9 @@ void snd_pcm_tick_elapsed(snd_pcm_substream_t *substream) * Even if more than one periods have elapsed since the last call, you * have to call this only once. */ -void snd_pcm_period_elapsed(snd_pcm_substream_t *substream) +void snd_pcm_period_elapsed(struct snd_pcm_substream *substream) { - snd_pcm_runtime_t *runtime; + struct snd_pcm_runtime *runtime; unsigned long flags; snd_assert(substream != NULL, return); @@ -2104,12 +2101,12 @@ void snd_pcm_period_elapsed(snd_pcm_substream_t *substream) kill_fasync(&runtime->fasync, SIGIO, POLL_IN); } -static int snd_pcm_lib_write_transfer(snd_pcm_substream_t *substream, +static int snd_pcm_lib_write_transfer(struct snd_pcm_substream *substream, unsigned int hwoff, unsigned long data, unsigned int off, snd_pcm_uframes_t frames) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; int err; char __user *buf = (char __user *) data + frames_to_bytes(runtime, off); if (substream->ops->copy) { @@ -2124,17 +2121,17 @@ static int snd_pcm_lib_write_transfer(snd_pcm_substream_t *substream, return 0; } -typedef int (*transfer_f)(snd_pcm_substream_t *substream, unsigned int hwoff, +typedef int (*transfer_f)(struct snd_pcm_substream *substream, unsigned int hwoff, unsigned long data, unsigned int off, snd_pcm_uframes_t size); -static snd_pcm_sframes_t snd_pcm_lib_write1(snd_pcm_substream_t *substream, +static snd_pcm_sframes_t snd_pcm_lib_write1(struct snd_pcm_substream *substream, unsigned long data, snd_pcm_uframes_t size, int nonblock, transfer_f transfer) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; snd_pcm_uframes_t xfer = 0; snd_pcm_uframes_t offset = 0; int err = 0; @@ -2290,9 +2287,9 @@ static snd_pcm_sframes_t snd_pcm_lib_write1(snd_pcm_substream_t *substream, return xfer > 0 ? (snd_pcm_sframes_t)xfer : err; } -snd_pcm_sframes_t snd_pcm_lib_write(snd_pcm_substream_t *substream, const void __user *buf, snd_pcm_uframes_t size) +snd_pcm_sframes_t snd_pcm_lib_write(struct snd_pcm_substream *substream, const void __user *buf, snd_pcm_uframes_t size) { - snd_pcm_runtime_t *runtime; + struct snd_pcm_runtime *runtime; int nonblock; snd_assert(substream != NULL, return -ENXIO); @@ -2306,7 +2303,7 @@ snd_pcm_sframes_t snd_pcm_lib_write(snd_pcm_substream_t *substream, const void _ nonblock = !!(substream->ffile->f_flags & O_NONBLOCK); #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE) if (substream->oss.oss) { - snd_pcm_oss_setup_t *setup = substream->oss.setup; + struct snd_pcm_oss_setup *setup = substream->oss.setup; if (setup != NULL) { if (setup->nonblock) nonblock = 1; @@ -2323,12 +2320,12 @@ snd_pcm_sframes_t snd_pcm_lib_write(snd_pcm_substream_t *substream, const void _ snd_pcm_lib_write_transfer); } -static int snd_pcm_lib_writev_transfer(snd_pcm_substream_t *substream, +static int snd_pcm_lib_writev_transfer(struct snd_pcm_substream *substream, unsigned int hwoff, unsigned long data, unsigned int off, snd_pcm_uframes_t frames) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; int err; void __user **bufs = (void __user **)data; int channels = runtime->channels; @@ -2363,11 +2360,11 @@ static int snd_pcm_lib_writev_transfer(snd_pcm_substream_t *substream, return 0; } -snd_pcm_sframes_t snd_pcm_lib_writev(snd_pcm_substream_t *substream, +snd_pcm_sframes_t snd_pcm_lib_writev(struct snd_pcm_substream *substream, void __user **bufs, snd_pcm_uframes_t frames) { - snd_pcm_runtime_t *runtime; + struct snd_pcm_runtime *runtime; int nonblock; snd_assert(substream != NULL, return -ENXIO); @@ -2381,7 +2378,7 @@ snd_pcm_sframes_t snd_pcm_lib_writev(snd_pcm_substream_t *substream, nonblock = !!(substream->ffile->f_flags & O_NONBLOCK); #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE) if (substream->oss.oss) { - snd_pcm_oss_setup_t *setup = substream->oss.setup; + struct snd_pcm_oss_setup *setup = substream->oss.setup; if (setup != NULL) { if (setup->nonblock) nonblock = 1; @@ -2397,12 +2394,12 @@ snd_pcm_sframes_t snd_pcm_lib_writev(snd_pcm_substream_t *substream, nonblock, snd_pcm_lib_writev_transfer); } -static int snd_pcm_lib_read_transfer(snd_pcm_substream_t *substream, +static int snd_pcm_lib_read_transfer(struct snd_pcm_substream *substream, unsigned int hwoff, unsigned long data, unsigned int off, snd_pcm_uframes_t frames) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; int err; char __user *buf = (char __user *) data + frames_to_bytes(runtime, off); if (substream->ops->copy) { @@ -2417,13 +2414,13 @@ static int snd_pcm_lib_read_transfer(snd_pcm_substream_t *substream, return 0; } -static snd_pcm_sframes_t snd_pcm_lib_read1(snd_pcm_substream_t *substream, +static snd_pcm_sframes_t snd_pcm_lib_read1(struct snd_pcm_substream *substream, unsigned long data, snd_pcm_uframes_t size, int nonblock, transfer_f transfer) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; snd_pcm_uframes_t xfer = 0; snd_pcm_uframes_t offset = 0; int err = 0; @@ -2587,9 +2584,9 @@ static snd_pcm_sframes_t snd_pcm_lib_read1(snd_pcm_substream_t *substream, return xfer > 0 ? (snd_pcm_sframes_t)xfer : err; } -snd_pcm_sframes_t snd_pcm_lib_read(snd_pcm_substream_t *substream, void __user *buf, snd_pcm_uframes_t size) +snd_pcm_sframes_t snd_pcm_lib_read(struct snd_pcm_substream *substream, void __user *buf, snd_pcm_uframes_t size) { - snd_pcm_runtime_t *runtime; + struct snd_pcm_runtime *runtime; int nonblock; snd_assert(substream != NULL, return -ENXIO); @@ -2603,7 +2600,7 @@ snd_pcm_sframes_t snd_pcm_lib_read(snd_pcm_substream_t *substream, void __user * nonblock = !!(substream->ffile->f_flags & O_NONBLOCK); #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE) if (substream->oss.oss) { - snd_pcm_oss_setup_t *setup = substream->oss.setup; + struct snd_pcm_oss_setup *setup = substream->oss.setup; if (setup != NULL) { if (setup->nonblock) nonblock = 1; @@ -2617,12 +2614,12 @@ snd_pcm_sframes_t snd_pcm_lib_read(snd_pcm_substream_t *substream, void __user * return snd_pcm_lib_read1(substream, (unsigned long)buf, size, nonblock, snd_pcm_lib_read_transfer); } -static int snd_pcm_lib_readv_transfer(snd_pcm_substream_t *substream, +static int snd_pcm_lib_readv_transfer(struct snd_pcm_substream *substream, unsigned int hwoff, unsigned long data, unsigned int off, snd_pcm_uframes_t frames) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; int err; void __user **bufs = (void __user **)data; int channels = runtime->channels; @@ -2654,11 +2651,11 @@ static int snd_pcm_lib_readv_transfer(snd_pcm_substream_t *substream, return 0; } -snd_pcm_sframes_t snd_pcm_lib_readv(snd_pcm_substream_t *substream, +snd_pcm_sframes_t snd_pcm_lib_readv(struct snd_pcm_substream *substream, void __user **bufs, snd_pcm_uframes_t frames) { - snd_pcm_runtime_t *runtime; + struct snd_pcm_runtime *runtime; int nonblock; snd_assert(substream != NULL, return -ENXIO); @@ -2672,7 +2669,7 @@ snd_pcm_sframes_t snd_pcm_lib_readv(snd_pcm_substream_t *substream, nonblock = !!(substream->ffile->f_flags & O_NONBLOCK); #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE) if (substream->oss.oss) { - snd_pcm_oss_setup_t *setup = substream->oss.setup; + struct snd_pcm_oss_setup *setup = substream->oss.setup; if (setup != NULL) { if (setup->nonblock) nonblock = 1; diff --git a/sound/core/pcm_memory.c b/sound/core/pcm_memory.c index b3f5344f60b..a0119ae67dc 100644 --- a/sound/core/pcm_memory.c +++ b/sound/core/pcm_memory.c @@ -46,7 +46,7 @@ static const size_t snd_minimum_buffer = 16384; * * the minimum size is snd_minimum_buffer. it should be power of 2. */ -static int preallocate_pcm_pages(snd_pcm_substream_t *substream, size_t size) +static int preallocate_pcm_pages(struct snd_pcm_substream *substream, size_t size) { struct snd_dma_buffer *dmab = &substream->dma_buffer; int err; @@ -78,7 +78,7 @@ static int preallocate_pcm_pages(snd_pcm_substream_t *substream, size_t size) /* * release the preallocated buffer if not yet done. */ -static void snd_pcm_lib_preallocate_dma_free(snd_pcm_substream_t *substream) +static void snd_pcm_lib_preallocate_dma_free(struct snd_pcm_substream *substream) { if (substream->dma_buffer.area == NULL) return; @@ -97,13 +97,11 @@ static void snd_pcm_lib_preallocate_dma_free(snd_pcm_substream_t *substream) * * Returns zero if successful, or a negative error code on failure. */ -int snd_pcm_lib_preallocate_free(snd_pcm_substream_t *substream) +int snd_pcm_lib_preallocate_free(struct snd_pcm_substream *substream) { snd_pcm_lib_preallocate_dma_free(substream); - if (substream->proc_prealloc_entry) { - snd_info_unregister(substream->proc_prealloc_entry); - substream->proc_prealloc_entry = NULL; - } + snd_info_unregister(substream->proc_prealloc_entry); + substream->proc_prealloc_entry = NULL; return 0; } @@ -115,9 +113,9 @@ int snd_pcm_lib_preallocate_free(snd_pcm_substream_t *substream) * * Returns zero if successful, or a negative error code on failure. */ -int snd_pcm_lib_preallocate_free_for_all(snd_pcm_t *pcm) +int snd_pcm_lib_preallocate_free_for_all(struct snd_pcm *pcm) { - snd_pcm_substream_t *substream; + struct snd_pcm_substream *substream; int stream; for (stream = 0; stream < 2; stream++) @@ -126,15 +124,16 @@ int snd_pcm_lib_preallocate_free_for_all(snd_pcm_t *pcm) return 0; } +#ifdef CONFIG_PROC_FS /* * read callback for prealloc proc file * * prints the current allocated size in kB. */ -static void snd_pcm_lib_preallocate_proc_read(snd_info_entry_t *entry, - snd_info_buffer_t *buffer) +static void snd_pcm_lib_preallocate_proc_read(struct snd_info_entry *entry, + struct snd_info_buffer *buffer) { - snd_pcm_substream_t *substream = (snd_pcm_substream_t *)entry->private_data; + struct snd_pcm_substream *substream = entry->private_data; snd_iprintf(buffer, "%lu\n", (unsigned long) substream->dma_buffer.bytes / 1024); } @@ -143,10 +142,10 @@ static void snd_pcm_lib_preallocate_proc_read(snd_info_entry_t *entry, * * accepts the preallocation size in kB. */ -static void snd_pcm_lib_preallocate_proc_write(snd_info_entry_t *entry, - snd_info_buffer_t *buffer) +static void snd_pcm_lib_preallocate_proc_write(struct snd_info_entry *entry, + struct snd_info_buffer *buffer) { - snd_pcm_substream_t *substream = (snd_pcm_substream_t *)entry->private_data; + struct snd_pcm_substream *substream = entry->private_data; char line[64], str[64]; size_t size; struct snd_dma_buffer new_dmab; @@ -185,20 +184,10 @@ static void snd_pcm_lib_preallocate_proc_write(snd_info_entry_t *entry, } } -/* - * pre-allocate the buffer and create a proc file for the substream - */ -static int snd_pcm_lib_preallocate_pages1(snd_pcm_substream_t *substream, - size_t size, size_t max) +static inline void preallocate_info_init(struct snd_pcm_substream *substream) { - snd_info_entry_t *entry; + struct snd_info_entry *entry; - if (size > 0 && preallocate_dma && substream->number < maximum_substreams) - preallocate_pcm_pages(substream, size); - - if (substream->dma_buffer.bytes > 0) - substream->buffer_bytes_max = substream->dma_buffer.bytes; - substream->dma_max = max; if ((entry = snd_info_create_card_entry(substream->pcm->card, "prealloc", substream->proc_root)) != NULL) { entry->c.text.read_size = 64; entry->c.text.read = snd_pcm_lib_preallocate_proc_read; @@ -212,6 +201,26 @@ static int snd_pcm_lib_preallocate_pages1(snd_pcm_substream_t *substream, } } substream->proc_prealloc_entry = entry; +} + +#else /* !CONFIG_PROC_FS */ +#define preallocate_info_init(s) +#endif + +/* + * pre-allocate the buffer and create a proc file for the substream + */ +static int snd_pcm_lib_preallocate_pages1(struct snd_pcm_substream *substream, + size_t size, size_t max) +{ + + if (size > 0 && preallocate_dma && substream->number < maximum_substreams) + preallocate_pcm_pages(substream, size); + + if (substream->dma_buffer.bytes > 0) + substream->buffer_bytes_max = substream->dma_buffer.bytes; + substream->dma_max = max; + preallocate_info_init(substream); return 0; } @@ -233,7 +242,7 @@ static int snd_pcm_lib_preallocate_pages1(snd_pcm_substream_t *substream, * * Returns zero if successful, or a negative error code on failure. */ -int snd_pcm_lib_preallocate_pages(snd_pcm_substream_t *substream, +int snd_pcm_lib_preallocate_pages(struct snd_pcm_substream *substream, int type, struct device *data, size_t size, size_t max) { @@ -255,11 +264,11 @@ int snd_pcm_lib_preallocate_pages(snd_pcm_substream_t *substream, * * Returns zero if successful, or a negative error code on failure. */ -int snd_pcm_lib_preallocate_pages_for_all(snd_pcm_t *pcm, +int snd_pcm_lib_preallocate_pages_for_all(struct snd_pcm *pcm, int type, void *data, size_t size, size_t max) { - snd_pcm_substream_t *substream; + struct snd_pcm_substream *substream; int stream, err; for (stream = 0; stream < 2; stream++) @@ -277,7 +286,7 @@ int snd_pcm_lib_preallocate_pages_for_all(snd_pcm_t *pcm, * Returns the page struct at the given buffer offset. * Used as the page callback of PCM ops. */ -struct page *snd_pcm_sgbuf_ops_page(snd_pcm_substream_t *substream, unsigned long offset) +struct page *snd_pcm_sgbuf_ops_page(struct snd_pcm_substream *substream, unsigned long offset) { struct snd_sg_buf *sgbuf = snd_pcm_substream_sgbuf(substream); @@ -298,9 +307,9 @@ struct page *snd_pcm_sgbuf_ops_page(snd_pcm_substream_t *substream, unsigned lon * Returns 1 if the buffer is changed, 0 if not changed, or a negative * code on failure. */ -int snd_pcm_lib_malloc_pages(snd_pcm_substream_t *substream, size_t size) +int snd_pcm_lib_malloc_pages(struct snd_pcm_substream *substream, size_t size) { - snd_pcm_runtime_t *runtime; + struct snd_pcm_runtime *runtime; struct snd_dma_buffer *dmab = NULL; snd_assert(substream->dma_buffer.dev.type != SNDRV_DMA_TYPE_UNKNOWN, return -EINVAL); @@ -318,7 +327,8 @@ int snd_pcm_lib_malloc_pages(snd_pcm_substream_t *substream, size_t size) } snd_pcm_lib_free_pages(substream); } - if (substream->dma_buffer.area != NULL && substream->dma_buffer.bytes >= size) { + if (substream->dma_buffer.area != NULL && + substream->dma_buffer.bytes >= size) { dmab = &substream->dma_buffer; /* use the pre-allocated buffer */ } else { dmab = kzalloc(sizeof(*dmab), GFP_KERNEL); @@ -345,9 +355,9 @@ int snd_pcm_lib_malloc_pages(snd_pcm_substream_t *substream, size_t size) * * Returns zero if successful, or a negative error code on failure. */ -int snd_pcm_lib_free_pages(snd_pcm_substream_t *substream) +int snd_pcm_lib_free_pages(struct snd_pcm_substream *substream) { - snd_pcm_runtime_t *runtime; + struct snd_pcm_runtime *runtime; snd_assert(substream != NULL, return -EINVAL); runtime = substream->runtime; diff --git a/sound/core/pcm_misc.c b/sound/core/pcm_misc.c index 1453743e4da..593c77f4d18 100644 --- a/sound/core/pcm_misc.c +++ b/sound/core/pcm_misc.c @@ -441,7 +441,7 @@ snd_pcm_format_t snd_pcm_build_linear_format(int width, int unsignd, int big_end * * Returns zero if successful. */ -int snd_pcm_limit_hw_rates(snd_pcm_runtime_t *runtime) +int snd_pcm_limit_hw_rates(struct snd_pcm_runtime *runtime) { static unsigned rates[] = { /* ATTENTION: these values depend on the definition in pcm.h! */ diff --git a/sound/core/pcm_native.c b/sound/core/pcm_native.c index 16e252f5495..f3d5de7b55a 100644 --- a/sound/core/pcm_native.c +++ b/sound/core/pcm_native.c @@ -39,11 +39,11 @@ * Compatibility */ -struct sndrv_pcm_hw_params_old { +struct snd_pcm_hw_params_old { unsigned int flags; unsigned int masks[SNDRV_PCM_HW_PARAM_SUBFORMAT - SNDRV_PCM_HW_PARAM_ACCESS + 1]; - struct sndrv_interval intervals[SNDRV_PCM_HW_PARAM_TICK_TIME - + struct snd_interval intervals[SNDRV_PCM_HW_PARAM_TICK_TIME - SNDRV_PCM_HW_PARAM_SAMPLE_BITS + 1]; unsigned int rmask; unsigned int cmask; @@ -51,15 +51,20 @@ struct sndrv_pcm_hw_params_old { unsigned int msbits; unsigned int rate_num; unsigned int rate_den; - sndrv_pcm_uframes_t fifo_size; + snd_pcm_uframes_t fifo_size; unsigned char reserved[64]; }; -#define SNDRV_PCM_IOCTL_HW_REFINE_OLD _IOWR('A', 0x10, struct sndrv_pcm_hw_params_old) -#define SNDRV_PCM_IOCTL_HW_PARAMS_OLD _IOWR('A', 0x11, struct sndrv_pcm_hw_params_old) +#ifdef CONFIG_SND_SUPPORT_OLD_API +#define SNDRV_PCM_IOCTL_HW_REFINE_OLD _IOWR('A', 0x10, struct snd_pcm_hw_params_old) +#define SNDRV_PCM_IOCTL_HW_PARAMS_OLD _IOWR('A', 0x11, struct snd_pcm_hw_params_old) -static int snd_pcm_hw_refine_old_user(snd_pcm_substream_t * substream, struct sndrv_pcm_hw_params_old __user * _oparams); -static int snd_pcm_hw_params_old_user(snd_pcm_substream_t * substream, struct sndrv_pcm_hw_params_old __user * _oparams); +static int snd_pcm_hw_refine_old_user(struct snd_pcm_substream *substream, + struct snd_pcm_hw_params_old __user * _oparams); +static int snd_pcm_hw_params_old_user(struct snd_pcm_substream *substream, + struct snd_pcm_hw_params_old __user * _oparams); +#endif +static int snd_pcm_open(struct file *file, struct snd_pcm *pcm, int stream); /* * @@ -83,11 +88,11 @@ static inline void snd_leave_user(mm_segment_t fs) -int snd_pcm_info(snd_pcm_substream_t * substream, snd_pcm_info_t *info) +int snd_pcm_info(struct snd_pcm_substream *substream, struct snd_pcm_info *info) { - snd_pcm_runtime_t * runtime; - snd_pcm_t *pcm = substream->pcm; - snd_pcm_str_t *pstr = substream->pstr; + struct snd_pcm_runtime *runtime; + struct snd_pcm *pcm = substream->pcm; + struct snd_pcm_str *pstr = substream->pstr; snd_assert(substream != NULL, return -ENXIO); memset(info, 0, sizeof(*info)); @@ -111,9 +116,10 @@ int snd_pcm_info(snd_pcm_substream_t * substream, snd_pcm_info_t *info) return 0; } -int snd_pcm_info_user(snd_pcm_substream_t * substream, snd_pcm_info_t __user * _info) +int snd_pcm_info_user(struct snd_pcm_substream *substream, + struct snd_pcm_info __user * _info) { - snd_pcm_info_t *info; + struct snd_pcm_info *info; int err; info = kmalloc(sizeof(*info), GFP_KERNEL); @@ -151,14 +157,14 @@ char *snd_pcm_hw_param_names[] = { }; #endif -int snd_pcm_hw_refine(snd_pcm_substream_t *substream, - snd_pcm_hw_params_t *params) +int snd_pcm_hw_refine(struct snd_pcm_substream *substream, + struct snd_pcm_hw_params *params) { unsigned int k; - snd_pcm_hardware_t *hw; - snd_interval_t *i = NULL; - snd_mask_t *m = NULL; - snd_pcm_hw_constraints_t *constrs = &substream->runtime->hw_constraints; + struct snd_pcm_hardware *hw; + struct snd_interval *i = NULL; + struct snd_mask *m = NULL; + struct snd_pcm_hw_constraints *constrs = &substream->runtime->hw_constraints; unsigned int rstamps[constrs->rules_num]; unsigned int vstamps[SNDRV_PCM_HW_PARAM_LAST_INTERVAL + 1]; unsigned int stamp = 2; @@ -231,7 +237,7 @@ int snd_pcm_hw_refine(snd_pcm_substream_t *substream, do { again = 0; for (k = 0; k < constrs->rules_num; k++) { - snd_pcm_hw_rule_t *r = &constrs->rules[k]; + struct snd_pcm_hw_rule *r = &constrs->rules[k]; unsigned int d; int doit = 0; if (r->cond && !(r->cond & params->flags)) @@ -313,9 +319,10 @@ int snd_pcm_hw_refine(snd_pcm_substream_t *substream, return 0; } -static int snd_pcm_hw_refine_user(snd_pcm_substream_t * substream, snd_pcm_hw_params_t __user * _params) +static int snd_pcm_hw_refine_user(struct snd_pcm_substream *substream, + struct snd_pcm_hw_params __user * _params) { - snd_pcm_hw_params_t *params; + struct snd_pcm_hw_params *params; int err; params = kmalloc(sizeof(*params), GFP_KERNEL); @@ -337,10 +344,10 @@ out: return err; } -static int snd_pcm_hw_params(snd_pcm_substream_t *substream, - snd_pcm_hw_params_t *params) +static int snd_pcm_hw_params(struct snd_pcm_substream *substream, + struct snd_pcm_hw_params *params) { - snd_pcm_runtime_t *runtime; + struct snd_pcm_runtime *runtime; int err; unsigned int bits; snd_pcm_uframes_t frames; @@ -432,9 +439,10 @@ static int snd_pcm_hw_params(snd_pcm_substream_t *substream, return err; } -static int snd_pcm_hw_params_user(snd_pcm_substream_t * substream, snd_pcm_hw_params_t __user * _params) +static int snd_pcm_hw_params_user(struct snd_pcm_substream *substream, + struct snd_pcm_hw_params __user * _params) { - snd_pcm_hw_params_t *params; + struct snd_pcm_hw_params *params; int err; params = kmalloc(sizeof(*params), GFP_KERNEL); @@ -456,9 +464,9 @@ out: return err; } -static int snd_pcm_hw_free(snd_pcm_substream_t * substream) +static int snd_pcm_hw_free(struct snd_pcm_substream *substream) { - snd_pcm_runtime_t *runtime; + struct snd_pcm_runtime *runtime; int result = 0; snd_assert(substream != NULL, return -ENXIO); @@ -482,9 +490,10 @@ static int snd_pcm_hw_free(snd_pcm_substream_t * substream) return result; } -static int snd_pcm_sw_params(snd_pcm_substream_t * substream, snd_pcm_sw_params_t *params) +static int snd_pcm_sw_params(struct snd_pcm_substream *substream, + struct snd_pcm_sw_params *params) { - snd_pcm_runtime_t *runtime; + struct snd_pcm_runtime *runtime; snd_assert(substream != NULL, return -ENXIO); runtime = substream->runtime; @@ -537,9 +546,10 @@ static int snd_pcm_sw_params(snd_pcm_substream_t * substream, snd_pcm_sw_params_ return 0; } -static int snd_pcm_sw_params_user(snd_pcm_substream_t * substream, snd_pcm_sw_params_t __user * _params) +static int snd_pcm_sw_params_user(struct snd_pcm_substream *substream, + struct snd_pcm_sw_params __user * _params) { - snd_pcm_sw_params_t params; + struct snd_pcm_sw_params params; int err; if (copy_from_user(¶ms, _params, sizeof(params))) return -EFAULT; @@ -549,10 +559,10 @@ static int snd_pcm_sw_params_user(snd_pcm_substream_t * substream, snd_pcm_sw_pa return err; } -int snd_pcm_status(snd_pcm_substream_t *substream, - snd_pcm_status_t *status) +int snd_pcm_status(struct snd_pcm_substream *substream, + struct snd_pcm_status *status) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; snd_pcm_stream_lock_irq(substream); status->state = runtime->status->state; @@ -593,10 +603,11 @@ int snd_pcm_status(snd_pcm_substream_t *substream, return 0; } -static int snd_pcm_status_user(snd_pcm_substream_t * substream, snd_pcm_status_t __user * _status) +static int snd_pcm_status_user(struct snd_pcm_substream *substream, + struct snd_pcm_status __user * _status) { - snd_pcm_status_t status; - snd_pcm_runtime_t *runtime; + struct snd_pcm_status status; + struct snd_pcm_runtime *runtime; int res; snd_assert(substream != NULL, return -ENXIO); @@ -610,9 +621,10 @@ static int snd_pcm_status_user(snd_pcm_substream_t * substream, snd_pcm_status_t return 0; } -static int snd_pcm_channel_info(snd_pcm_substream_t * substream, snd_pcm_channel_info_t * info) +static int snd_pcm_channel_info(struct snd_pcm_substream *substream, + struct snd_pcm_channel_info * info) { - snd_pcm_runtime_t *runtime; + struct snd_pcm_runtime *runtime; unsigned int channel; snd_assert(substream != NULL, return -ENXIO); @@ -631,9 +643,10 @@ static int snd_pcm_channel_info(snd_pcm_substream_t * substream, snd_pcm_channel return substream->ops->ioctl(substream, SNDRV_PCM_IOCTL1_CHANNEL_INFO, info); } -static int snd_pcm_channel_info_user(snd_pcm_substream_t * substream, snd_pcm_channel_info_t __user * _info) +static int snd_pcm_channel_info_user(struct snd_pcm_substream *substream, + struct snd_pcm_channel_info __user * _info) { - snd_pcm_channel_info_t info; + struct snd_pcm_channel_info info; int res; if (copy_from_user(&info, _info, sizeof(info))) @@ -646,9 +659,9 @@ static int snd_pcm_channel_info_user(snd_pcm_substream_t * substream, snd_pcm_ch return 0; } -static void snd_pcm_trigger_tstamp(snd_pcm_substream_t *substream) +static void snd_pcm_trigger_tstamp(struct snd_pcm_substream *substream) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; if (runtime->trigger_master == NULL) return; if (runtime->trigger_master == substream) { @@ -661,10 +674,10 @@ static void snd_pcm_trigger_tstamp(snd_pcm_substream_t *substream) } struct action_ops { - int (*pre_action)(snd_pcm_substream_t *substream, int state); - int (*do_action)(snd_pcm_substream_t *substream, int state); - void (*undo_action)(snd_pcm_substream_t *substream, int state); - void (*post_action)(snd_pcm_substream_t *substream, int state); + int (*pre_action)(struct snd_pcm_substream *substream, int state); + int (*do_action)(struct snd_pcm_substream *substream, int state); + void (*undo_action)(struct snd_pcm_substream *substream, int state); + void (*post_action)(struct snd_pcm_substream *substream, int state); }; /* @@ -673,12 +686,12 @@ struct action_ops { * Note2: call with calling stream lock + link lock */ static int snd_pcm_action_group(struct action_ops *ops, - snd_pcm_substream_t *substream, + struct snd_pcm_substream *substream, int state, int do_lock) { struct list_head *pos; - snd_pcm_substream_t *s = NULL; - snd_pcm_substream_t *s1; + struct snd_pcm_substream *s = NULL; + struct snd_pcm_substream *s1; int res = 0; snd_pcm_group_for_each(pos, substream) { @@ -727,7 +740,7 @@ static int snd_pcm_action_group(struct action_ops *ops, * Note: call with stream lock */ static int snd_pcm_action_single(struct action_ops *ops, - snd_pcm_substream_t *substream, + struct snd_pcm_substream *substream, int state) { int res; @@ -747,7 +760,7 @@ static int snd_pcm_action_single(struct action_ops *ops, * Note: call with stream lock */ static int snd_pcm_action(struct action_ops *ops, - snd_pcm_substream_t *substream, + struct snd_pcm_substream *substream, int state) { int res; @@ -770,7 +783,7 @@ static int snd_pcm_action(struct action_ops *ops, * Note: don't use any locks before */ static int snd_pcm_action_lock_irq(struct action_ops *ops, - snd_pcm_substream_t *substream, + struct snd_pcm_substream *substream, int state) { int res; @@ -794,7 +807,7 @@ static int snd_pcm_action_lock_irq(struct action_ops *ops, /* */ static int snd_pcm_action_nonatomic(struct action_ops *ops, - snd_pcm_substream_t *substream, + struct snd_pcm_substream *substream, int state) { int res; @@ -811,9 +824,9 @@ static int snd_pcm_action_nonatomic(struct action_ops *ops, /* * start callbacks */ -static int snd_pcm_pre_start(snd_pcm_substream_t *substream, int state) +static int snd_pcm_pre_start(struct snd_pcm_substream *substream, int state) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; if (runtime->status->state != SNDRV_PCM_STATE_PREPARED) return -EBADFD; if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK && @@ -823,22 +836,22 @@ static int snd_pcm_pre_start(snd_pcm_substream_t *substream, int state) return 0; } -static int snd_pcm_do_start(snd_pcm_substream_t *substream, int state) +static int snd_pcm_do_start(struct snd_pcm_substream *substream, int state) { if (substream->runtime->trigger_master != substream) return 0; return substream->ops->trigger(substream, SNDRV_PCM_TRIGGER_START); } -static void snd_pcm_undo_start(snd_pcm_substream_t *substream, int state) +static void snd_pcm_undo_start(struct snd_pcm_substream *substream, int state) { if (substream->runtime->trigger_master == substream) substream->ops->trigger(substream, SNDRV_PCM_TRIGGER_STOP); } -static void snd_pcm_post_start(snd_pcm_substream_t *substream, int state) +static void snd_pcm_post_start(struct snd_pcm_substream *substream, int state) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; snd_pcm_trigger_tstamp(substream); runtime->status->state = state; if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK && @@ -847,7 +860,8 @@ static void snd_pcm_post_start(snd_pcm_substream_t *substream, int state) if (runtime->sleep_min) snd_pcm_tick_prepare(substream); if (substream->timer) - snd_timer_notify(substream->timer, SNDRV_TIMER_EVENT_MSTART, &runtime->trigger_tstamp); + snd_timer_notify(substream->timer, SNDRV_TIMER_EVENT_MSTART, + &runtime->trigger_tstamp); } static struct action_ops snd_pcm_action_start = { @@ -863,24 +877,25 @@ static struct action_ops snd_pcm_action_start = { * * Start all linked streams. */ -int snd_pcm_start(snd_pcm_substream_t *substream) +int snd_pcm_start(struct snd_pcm_substream *substream) { - return snd_pcm_action(&snd_pcm_action_start, substream, SNDRV_PCM_STATE_RUNNING); + return snd_pcm_action(&snd_pcm_action_start, substream, + SNDRV_PCM_STATE_RUNNING); } /* * stop callbacks */ -static int snd_pcm_pre_stop(snd_pcm_substream_t *substream, int state) +static int snd_pcm_pre_stop(struct snd_pcm_substream *substream, int state) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; if (runtime->status->state == SNDRV_PCM_STATE_OPEN) return -EBADFD; runtime->trigger_master = substream; return 0; } -static int snd_pcm_do_stop(snd_pcm_substream_t *substream, int state) +static int snd_pcm_do_stop(struct snd_pcm_substream *substream, int state) { if (substream->runtime->trigger_master == substream && snd_pcm_running(substream)) @@ -888,13 +903,14 @@ static int snd_pcm_do_stop(snd_pcm_substream_t *substream, int state) return 0; /* unconditonally stop all substreams */ } -static void snd_pcm_post_stop(snd_pcm_substream_t *substream, int state) +static void snd_pcm_post_stop(struct snd_pcm_substream *substream, int state) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; if (runtime->status->state != state) { snd_pcm_trigger_tstamp(substream); if (substream->timer) - snd_timer_notify(substream->timer, SNDRV_TIMER_EVENT_MSTOP, &runtime->trigger_tstamp); + snd_timer_notify(substream->timer, SNDRV_TIMER_EVENT_MSTOP, + &runtime->trigger_tstamp); runtime->status->state = state; snd_pcm_tick_set(substream, 0); } @@ -915,7 +931,7 @@ static struct action_ops snd_pcm_action_stop = { * Try to stop all running streams in the substream group. * The state of each stream is changed to the given value after that unconditionally. */ -int snd_pcm_stop(snd_pcm_substream_t *substream, int state) +int snd_pcm_stop(struct snd_pcm_substream *substream, int state) { return snd_pcm_action(&snd_pcm_action_stop, substream, state); } @@ -928,17 +944,18 @@ int snd_pcm_stop(snd_pcm_substream_t *substream, int state) * The state is changed to SETUP. * Unlike snd_pcm_stop(), this affects only the given stream. */ -int snd_pcm_drain_done(snd_pcm_substream_t *substream) +int snd_pcm_drain_done(struct snd_pcm_substream *substream) { - return snd_pcm_action_single(&snd_pcm_action_stop, substream, SNDRV_PCM_STATE_SETUP); + return snd_pcm_action_single(&snd_pcm_action_stop, substream, + SNDRV_PCM_STATE_SETUP); } /* * pause callbacks */ -static int snd_pcm_pre_pause(snd_pcm_substream_t *substream, int push) +static int snd_pcm_pre_pause(struct snd_pcm_substream *substream, int push) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; if (!(runtime->info & SNDRV_PCM_INFO_PAUSE)) return -ENOSYS; if (push) { @@ -950,7 +967,7 @@ static int snd_pcm_pre_pause(snd_pcm_substream_t *substream, int push) return 0; } -static int snd_pcm_do_pause(snd_pcm_substream_t *substream, int push) +static int snd_pcm_do_pause(struct snd_pcm_substream *substream, int push) { if (substream->runtime->trigger_master != substream) return 0; @@ -959,7 +976,7 @@ static int snd_pcm_do_pause(snd_pcm_substream_t *substream, int push) SNDRV_PCM_TRIGGER_PAUSE_RELEASE); } -static void snd_pcm_undo_pause(snd_pcm_substream_t *substream, int push) +static void snd_pcm_undo_pause(struct snd_pcm_substream *substream, int push) { if (substream->runtime->trigger_master == substream) substream->ops->trigger(substream, @@ -967,14 +984,16 @@ static void snd_pcm_undo_pause(snd_pcm_substream_t *substream, int push) SNDRV_PCM_TRIGGER_PAUSE_PUSH); } -static void snd_pcm_post_pause(snd_pcm_substream_t *substream, int push) +static void snd_pcm_post_pause(struct snd_pcm_substream *substream, int push) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; snd_pcm_trigger_tstamp(substream); if (push) { runtime->status->state = SNDRV_PCM_STATE_PAUSED; if (substream->timer) - snd_timer_notify(substream->timer, SNDRV_TIMER_EVENT_MPAUSE, &runtime->trigger_tstamp); + snd_timer_notify(substream->timer, + SNDRV_TIMER_EVENT_MPAUSE, + &runtime->trigger_tstamp); snd_pcm_tick_set(substream, 0); wake_up(&runtime->sleep); } else { @@ -982,7 +1001,9 @@ static void snd_pcm_post_pause(snd_pcm_substream_t *substream, int push) if (runtime->sleep_min) snd_pcm_tick_prepare(substream); if (substream->timer) - snd_timer_notify(substream->timer, SNDRV_TIMER_EVENT_MCONTINUE, &runtime->trigger_tstamp); + snd_timer_notify(substream->timer, + SNDRV_TIMER_EVENT_MCONTINUE, + &runtime->trigger_tstamp); } } @@ -996,7 +1017,7 @@ static struct action_ops snd_pcm_action_pause = { /* * Push/release the pause for all linked streams. */ -static int snd_pcm_pause(snd_pcm_substream_t *substream, int push) +static int snd_pcm_pause(struct snd_pcm_substream *substream, int push) { return snd_pcm_action(&snd_pcm_action_pause, substream, push); } @@ -1004,18 +1025,18 @@ static int snd_pcm_pause(snd_pcm_substream_t *substream, int push) #ifdef CONFIG_PM /* suspend */ -static int snd_pcm_pre_suspend(snd_pcm_substream_t *substream, int state) +static int snd_pcm_pre_suspend(struct snd_pcm_substream *substream, int state) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; if (runtime->status->state == SNDRV_PCM_STATE_SUSPENDED) return -EBUSY; runtime->trigger_master = substream; return 0; } -static int snd_pcm_do_suspend(snd_pcm_substream_t *substream, int state) +static int snd_pcm_do_suspend(struct snd_pcm_substream *substream, int state) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; if (runtime->trigger_master != substream) return 0; if (! snd_pcm_running(substream)) @@ -1024,12 +1045,13 @@ static int snd_pcm_do_suspend(snd_pcm_substream_t *substream, int state) return 0; /* suspend unconditionally */ } -static void snd_pcm_post_suspend(snd_pcm_substream_t *substream, int state) +static void snd_pcm_post_suspend(struct snd_pcm_substream *substream, int state) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; snd_pcm_trigger_tstamp(substream); if (substream->timer) - snd_timer_notify(substream->timer, SNDRV_TIMER_EVENT_MSUSPEND, &runtime->trigger_tstamp); + snd_timer_notify(substream->timer, SNDRV_TIMER_EVENT_MSUSPEND, + &runtime->trigger_tstamp); runtime->status->suspended_state = runtime->status->state; runtime->status->state = SNDRV_PCM_STATE_SUSPENDED; snd_pcm_tick_set(substream, 0); @@ -1049,11 +1071,14 @@ static struct action_ops snd_pcm_action_suspend = { * Trigger SUSPEND to all linked streams. * After this call, all streams are changed to SUSPENDED state. */ -int snd_pcm_suspend(snd_pcm_substream_t *substream) +int snd_pcm_suspend(struct snd_pcm_substream *substream) { int err; unsigned long flags; + if (! substream) + return 0; + snd_pcm_stream_lock_irqsave(substream, flags); err = snd_pcm_action(&snd_pcm_action_suspend, substream, 0); snd_pcm_stream_unlock_irqrestore(substream, flags); @@ -1067,13 +1092,17 @@ int snd_pcm_suspend(snd_pcm_substream_t *substream) * Trigger SUSPEND to all substreams in the given pcm. * After this call, all streams are changed to SUSPENDED state. */ -int snd_pcm_suspend_all(snd_pcm_t *pcm) +int snd_pcm_suspend_all(struct snd_pcm *pcm) { - snd_pcm_substream_t *substream; + struct snd_pcm_substream *substream; int stream, err = 0; + if (! pcm) + return 0; + for (stream = 0; stream < 2; stream++) { - for (substream = pcm->streams[stream].substream; substream; substream = substream->next) { + for (substream = pcm->streams[stream].substream; + substream; substream = substream->next) { /* FIXME: the open/close code should lock this as well */ if (substream->runtime == NULL) continue; @@ -1087,18 +1116,18 @@ int snd_pcm_suspend_all(snd_pcm_t *pcm) /* resume */ -static int snd_pcm_pre_resume(snd_pcm_substream_t *substream, int state) +static int snd_pcm_pre_resume(struct snd_pcm_substream *substream, int state) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; if (!(runtime->info & SNDRV_PCM_INFO_RESUME)) return -ENOSYS; runtime->trigger_master = substream; return 0; } -static int snd_pcm_do_resume(snd_pcm_substream_t *substream, int state) +static int snd_pcm_do_resume(struct snd_pcm_substream *substream, int state) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; if (runtime->trigger_master != substream) return 0; /* DMA not running previously? */ @@ -1109,19 +1138,20 @@ static int snd_pcm_do_resume(snd_pcm_substream_t *substream, int state) return substream->ops->trigger(substream, SNDRV_PCM_TRIGGER_RESUME); } -static void snd_pcm_undo_resume(snd_pcm_substream_t *substream, int state) +static void snd_pcm_undo_resume(struct snd_pcm_substream *substream, int state) { if (substream->runtime->trigger_master == substream && snd_pcm_running(substream)) substream->ops->trigger(substream, SNDRV_PCM_TRIGGER_SUSPEND); } -static void snd_pcm_post_resume(snd_pcm_substream_t *substream, int state) +static void snd_pcm_post_resume(struct snd_pcm_substream *substream, int state) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; snd_pcm_trigger_tstamp(substream); if (substream->timer) - snd_timer_notify(substream->timer, SNDRV_TIMER_EVENT_MRESUME, &runtime->trigger_tstamp); + snd_timer_notify(substream->timer, SNDRV_TIMER_EVENT_MRESUME, + &runtime->trigger_tstamp); runtime->status->state = runtime->status->suspended_state; if (runtime->sleep_min) snd_pcm_tick_prepare(substream); @@ -1134,9 +1164,9 @@ static struct action_ops snd_pcm_action_resume = { .post_action = snd_pcm_post_resume }; -static int snd_pcm_resume(snd_pcm_substream_t *substream) +static int snd_pcm_resume(struct snd_pcm_substream *substream) { - snd_card_t *card = substream->pcm->card; + struct snd_card *card = substream->pcm->card; int res; snd_power_lock(card); @@ -1148,7 +1178,7 @@ static int snd_pcm_resume(snd_pcm_substream_t *substream) #else -static int snd_pcm_resume(snd_pcm_substream_t *substream) +static int snd_pcm_resume(struct snd_pcm_substream *substream) { return -ENOSYS; } @@ -1160,10 +1190,10 @@ static int snd_pcm_resume(snd_pcm_substream_t *substream) * * Change the RUNNING stream(s) to XRUN state. */ -static int snd_pcm_xrun(snd_pcm_substream_t *substream) +static int snd_pcm_xrun(struct snd_pcm_substream *substream) { - snd_card_t *card = substream->pcm->card; - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_card *card = substream->pcm->card; + struct snd_pcm_runtime *runtime = substream->runtime; int result; snd_power_lock(card); @@ -1193,9 +1223,9 @@ static int snd_pcm_xrun(snd_pcm_substream_t *substream) /* * reset ioctl */ -static int snd_pcm_pre_reset(snd_pcm_substream_t * substream, int state) +static int snd_pcm_pre_reset(struct snd_pcm_substream *substream, int state) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; switch (runtime->status->state) { case SNDRV_PCM_STATE_RUNNING: case SNDRV_PCM_STATE_PREPARED: @@ -1207,23 +1237,24 @@ static int snd_pcm_pre_reset(snd_pcm_substream_t * substream, int state) } } -static int snd_pcm_do_reset(snd_pcm_substream_t * substream, int state) +static int snd_pcm_do_reset(struct snd_pcm_substream *substream, int state) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; int err = substream->ops->ioctl(substream, SNDRV_PCM_IOCTL1_RESET, NULL); if (err < 0) return err; // snd_assert(runtime->status->hw_ptr < runtime->buffer_size, ); runtime->hw_ptr_base = 0; - runtime->hw_ptr_interrupt = runtime->status->hw_ptr - runtime->status->hw_ptr % runtime->period_size; + runtime->hw_ptr_interrupt = runtime->status->hw_ptr - + runtime->status->hw_ptr % runtime->period_size; runtime->silence_start = runtime->status->hw_ptr; runtime->silence_filled = 0; return 0; } -static void snd_pcm_post_reset(snd_pcm_substream_t * substream, int state) +static void snd_pcm_post_reset(struct snd_pcm_substream *substream, int state) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; runtime->control->appl_ptr = runtime->status->hw_ptr; if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK && runtime->silence_size > 0) @@ -1236,7 +1267,7 @@ static struct action_ops snd_pcm_action_reset = { .post_action = snd_pcm_post_reset }; -static int snd_pcm_reset(snd_pcm_substream_t *substream) +static int snd_pcm_reset(struct snd_pcm_substream *substream) { return snd_pcm_action_nonatomic(&snd_pcm_action_reset, substream, 0); } @@ -1244,9 +1275,9 @@ static int snd_pcm_reset(snd_pcm_substream_t *substream) /* * prepare ioctl */ -static int snd_pcm_pre_prepare(snd_pcm_substream_t * substream, int state) +static int snd_pcm_pre_prepare(struct snd_pcm_substream *substream, int state) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; if (runtime->status->state == SNDRV_PCM_STATE_OPEN) return -EBADFD; if (snd_pcm_running(substream)) @@ -1254,7 +1285,7 @@ static int snd_pcm_pre_prepare(snd_pcm_substream_t * substream, int state) return 0; } -static int snd_pcm_do_prepare(snd_pcm_substream_t * substream, int state) +static int snd_pcm_do_prepare(struct snd_pcm_substream *substream, int state) { int err; err = substream->ops->prepare(substream); @@ -1263,9 +1294,9 @@ static int snd_pcm_do_prepare(snd_pcm_substream_t * substream, int state) return snd_pcm_do_reset(substream, 0); } -static void snd_pcm_post_prepare(snd_pcm_substream_t * substream, int state) +static void snd_pcm_post_prepare(struct snd_pcm_substream *substream, int state) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; runtime->control->appl_ptr = runtime->status->hw_ptr; runtime->status->state = SNDRV_PCM_STATE_PREPARED; } @@ -1282,10 +1313,10 @@ static struct action_ops snd_pcm_action_prepare = { * * Prepare the PCM substream to be triggerable. */ -int snd_pcm_prepare(snd_pcm_substream_t *substream) +int snd_pcm_prepare(struct snd_pcm_substream *substream) { int res; - snd_card_t *card = substream->pcm->card; + struct snd_card *card = substream->pcm->card; snd_power_lock(card); if ((res = snd_power_wait(card, SNDRV_CTL_POWER_D0, substream->ffile)) >= 0) @@ -1298,7 +1329,7 @@ int snd_pcm_prepare(snd_pcm_substream_t *substream) * drain ioctl */ -static int snd_pcm_pre_drain_init(snd_pcm_substream_t * substream, int state) +static int snd_pcm_pre_drain_init(struct snd_pcm_substream *substream, int state) { if (substream->ffile->f_flags & O_NONBLOCK) return -EAGAIN; @@ -1306,9 +1337,9 @@ static int snd_pcm_pre_drain_init(snd_pcm_substream_t * substream, int state) return 0; } -static int snd_pcm_do_drain_init(snd_pcm_substream_t * substream, int state) +static int snd_pcm_do_drain_init(struct snd_pcm_substream *substream, int state) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { switch (runtime->status->state) { case SNDRV_PCM_STATE_PREPARED: @@ -1336,7 +1367,7 @@ static int snd_pcm_do_drain_init(snd_pcm_substream_t * substream, int state) return 0; } -static void snd_pcm_post_drain_init(snd_pcm_substream_t * substream, int state) +static void snd_pcm_post_drain_init(struct snd_pcm_substream *substream, int state) { } @@ -1347,12 +1378,12 @@ static struct action_ops snd_pcm_action_drain_init = { }; struct drain_rec { - snd_pcm_substream_t *substream; + struct snd_pcm_substream *substream; wait_queue_t wait; snd_pcm_uframes_t stop_threshold; }; -static int snd_pcm_drop(snd_pcm_substream_t *substream); +static int snd_pcm_drop(struct snd_pcm_substream *substream); /* * Drain the stream(s). @@ -1361,10 +1392,10 @@ static int snd_pcm_drop(snd_pcm_substream_t *substream); * After this call, all streams are supposed to be either SETUP or DRAINING * (capture only) state. */ -static int snd_pcm_drain(snd_pcm_substream_t *substream) +static int snd_pcm_drain(struct snd_pcm_substream *substream) { - snd_card_t *card; - snd_pcm_runtime_t *runtime; + struct snd_card *card; + struct snd_pcm_runtime *runtime; struct list_head *pos; int result = 0; int i, num_drecs; @@ -1401,7 +1432,7 @@ static int snd_pcm_drain(snd_pcm_substream_t *substream) /* count only playback streams */ num_drecs = 0; snd_pcm_group_for_each(pos, substream) { - snd_pcm_substream_t *s = snd_pcm_group_substream_entry(pos); + struct snd_pcm_substream *s = snd_pcm_group_substream_entry(pos); runtime = s->runtime; if (s->stream == SNDRV_PCM_STREAM_PLAYBACK) { d = &drec[num_drecs++]; @@ -1487,10 +1518,10 @@ static int snd_pcm_drain(snd_pcm_substream_t *substream) * * Immediately put all linked substreams into SETUP state. */ -static int snd_pcm_drop(snd_pcm_substream_t *substream) +static int snd_pcm_drop(struct snd_pcm_substream *substream) { - snd_pcm_runtime_t *runtime; - snd_card_t *card; + struct snd_pcm_runtime *runtime; + struct snd_card *card; int result = 0; snd_assert(substream != NULL, return -ENXIO); @@ -1526,7 +1557,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; @@ -1537,8 +1569,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; } @@ -1548,12 +1580,12 @@ static struct file *snd_pcm_file_fd(int fd) /* * PCM link handling */ -static int snd_pcm_link(snd_pcm_substream_t *substream, int fd) +static int snd_pcm_link(struct snd_pcm_substream *substream, int fd) { int res = 0; struct file *file; - snd_pcm_file_t *pcm_file; - snd_pcm_substream_t *substream1; + struct snd_pcm_file *pcm_file; + struct snd_pcm_substream *substream1; file = snd_pcm_file_fd(fd); if (!file) @@ -1572,7 +1604,7 @@ static int snd_pcm_link(snd_pcm_substream_t *substream, int fd) goto _end; } if (!snd_pcm_stream_linked(substream)) { - substream->group = kmalloc(sizeof(snd_pcm_group_t), GFP_ATOMIC); + substream->group = kmalloc(sizeof(struct snd_pcm_group), GFP_ATOMIC); if (substream->group == NULL) { res = -ENOMEM; goto _end; @@ -1592,14 +1624,14 @@ static int snd_pcm_link(snd_pcm_substream_t *substream, int fd) return res; } -static void relink_to_local(snd_pcm_substream_t *substream) +static void relink_to_local(struct snd_pcm_substream *substream) { substream->group = &substream->self_group; INIT_LIST_HEAD(&substream->self_group.substreams); list_add_tail(&substream->link_list, &substream->self_group.substreams); } -static int snd_pcm_unlink(snd_pcm_substream_t *substream) +static int snd_pcm_unlink(struct snd_pcm_substream *substream) { struct list_head *pos; int res = 0; @@ -1629,51 +1661,51 @@ static int snd_pcm_unlink(snd_pcm_substream_t *substream) /* * hw configurator */ -static int snd_pcm_hw_rule_mul(snd_pcm_hw_params_t *params, - snd_pcm_hw_rule_t *rule) +static int snd_pcm_hw_rule_mul(struct snd_pcm_hw_params *params, + struct snd_pcm_hw_rule *rule) { - snd_interval_t t; + struct snd_interval t; snd_interval_mul(hw_param_interval_c(params, rule->deps[0]), hw_param_interval_c(params, rule->deps[1]), &t); return snd_interval_refine(hw_param_interval(params, rule->var), &t); } -static int snd_pcm_hw_rule_div(snd_pcm_hw_params_t *params, - snd_pcm_hw_rule_t *rule) +static int snd_pcm_hw_rule_div(struct snd_pcm_hw_params *params, + struct snd_pcm_hw_rule *rule) { - snd_interval_t t; + struct snd_interval t; snd_interval_div(hw_param_interval_c(params, rule->deps[0]), hw_param_interval_c(params, rule->deps[1]), &t); return snd_interval_refine(hw_param_interval(params, rule->var), &t); } -static int snd_pcm_hw_rule_muldivk(snd_pcm_hw_params_t *params, - snd_pcm_hw_rule_t *rule) +static int snd_pcm_hw_rule_muldivk(struct snd_pcm_hw_params *params, + struct snd_pcm_hw_rule *rule) { - snd_interval_t t; + struct snd_interval t; snd_interval_muldivk(hw_param_interval_c(params, rule->deps[0]), hw_param_interval_c(params, rule->deps[1]), (unsigned long) rule->private, &t); return snd_interval_refine(hw_param_interval(params, rule->var), &t); } -static int snd_pcm_hw_rule_mulkdiv(snd_pcm_hw_params_t *params, - snd_pcm_hw_rule_t *rule) +static int snd_pcm_hw_rule_mulkdiv(struct snd_pcm_hw_params *params, + struct snd_pcm_hw_rule *rule) { - snd_interval_t t; + struct snd_interval t; snd_interval_mulkdiv(hw_param_interval_c(params, rule->deps[0]), (unsigned long) rule->private, hw_param_interval_c(params, rule->deps[1]), &t); return snd_interval_refine(hw_param_interval(params, rule->var), &t); } -static int snd_pcm_hw_rule_format(snd_pcm_hw_params_t *params, - snd_pcm_hw_rule_t *rule) +static int snd_pcm_hw_rule_format(struct snd_pcm_hw_params *params, + struct snd_pcm_hw_rule *rule) { unsigned int k; - snd_interval_t *i = hw_param_interval(params, rule->deps[0]); - snd_mask_t m; - snd_mask_t *mask = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT); + struct snd_interval *i = hw_param_interval(params, rule->deps[0]); + struct snd_mask m; + struct snd_mask *mask = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT); snd_mask_any(&m); for (k = 0; k <= SNDRV_PCM_FORMAT_LAST; ++k) { int bits; @@ -1688,10 +1720,10 @@ static int snd_pcm_hw_rule_format(snd_pcm_hw_params_t *params, return snd_mask_refine(mask, &m); } -static int snd_pcm_hw_rule_sample_bits(snd_pcm_hw_params_t *params, - snd_pcm_hw_rule_t *rule) +static int snd_pcm_hw_rule_sample_bits(struct snd_pcm_hw_params *params, + struct snd_pcm_hw_rule *rule) { - snd_interval_t t; + struct snd_interval t; unsigned int k; t.min = UINT_MAX; t.max = 0; @@ -1720,19 +1752,19 @@ static int snd_pcm_hw_rule_sample_bits(snd_pcm_hw_params_t *params, static unsigned int rates[] = { 5512, 8000, 11025, 16000, 22050, 32000, 44100, 48000, 64000, 88200, 96000, 176400, 192000 }; -static int snd_pcm_hw_rule_rate(snd_pcm_hw_params_t *params, - snd_pcm_hw_rule_t *rule) +static int snd_pcm_hw_rule_rate(struct snd_pcm_hw_params *params, + struct snd_pcm_hw_rule *rule) { - snd_pcm_hardware_t *hw = rule->private; + struct snd_pcm_hardware *hw = rule->private; return snd_interval_list(hw_param_interval(params, rule->var), ARRAY_SIZE(rates), rates, hw->rates); } -static int snd_pcm_hw_rule_buffer_bytes_max(snd_pcm_hw_params_t *params, - snd_pcm_hw_rule_t *rule) +static int snd_pcm_hw_rule_buffer_bytes_max(struct snd_pcm_hw_params *params, + struct snd_pcm_hw_rule *rule) { - snd_interval_t t; - snd_pcm_substream_t *substream = rule->private; + struct snd_interval t; + struct snd_pcm_substream *substream = rule->private; t.min = 0; t.max = substream->buffer_bytes_max; t.openmin = 0; @@ -1741,10 +1773,10 @@ static int snd_pcm_hw_rule_buffer_bytes_max(snd_pcm_hw_params_t *params, return snd_interval_refine(hw_param_interval(params, rule->var), &t); } -int snd_pcm_hw_constraints_init(snd_pcm_substream_t *substream) +int snd_pcm_hw_constraints_init(struct snd_pcm_substream *substream) { - snd_pcm_runtime_t *runtime = substream->runtime; - snd_pcm_hw_constraints_t *constrs = &runtime->hw_constraints; + struct snd_pcm_runtime *runtime = substream->runtime; + struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints; int k, err; for (k = SNDRV_PCM_HW_PARAM_FIRST_MASK; k <= SNDRV_PCM_HW_PARAM_LAST_MASK; k++) { @@ -1865,10 +1897,10 @@ int snd_pcm_hw_constraints_init(snd_pcm_substream_t *substream) return 0; } -int snd_pcm_hw_constraints_complete(snd_pcm_substream_t *substream) +int snd_pcm_hw_constraints_complete(struct snd_pcm_substream *substream) { - snd_pcm_runtime_t *runtime = substream->runtime; - snd_pcm_hardware_t *hw = &runtime->hw; + struct snd_pcm_runtime *runtime = substream->runtime; + struct snd_pcm_hardware *hw = &runtime->hw; int err; unsigned int mask = 0; @@ -1941,17 +1973,17 @@ int snd_pcm_hw_constraints_complete(snd_pcm_substream_t *substream) return 0; } -static void snd_pcm_add_file(snd_pcm_str_t *str, - snd_pcm_file_t *pcm_file) +static void snd_pcm_add_file(struct snd_pcm_str *str, + struct snd_pcm_file *pcm_file) { pcm_file->next = str->files; str->files = pcm_file; } -static void snd_pcm_remove_file(snd_pcm_str_t *str, - snd_pcm_file_t *pcm_file) +static void snd_pcm_remove_file(struct snd_pcm_str *str, + struct snd_pcm_file *pcm_file) { - snd_pcm_file_t * pcm_file1; + struct snd_pcm_file * pcm_file1; if (str->files == pcm_file) { str->files = pcm_file->next; } else { @@ -1963,11 +1995,11 @@ static void snd_pcm_remove_file(snd_pcm_str_t *str, } } -static int snd_pcm_release_file(snd_pcm_file_t * pcm_file) +static int snd_pcm_release_file(struct snd_pcm_file * pcm_file) { - snd_pcm_substream_t *substream; - snd_pcm_runtime_t *runtime; - snd_pcm_str_t * str; + struct snd_pcm_substream *substream; + struct snd_pcm_runtime *runtime; + struct snd_pcm_str * str; snd_assert(pcm_file != NULL, return -ENXIO); substream = pcm_file->substream; @@ -1988,14 +2020,14 @@ static int snd_pcm_release_file(snd_pcm_file_t * pcm_file) } static int snd_pcm_open_file(struct file *file, - snd_pcm_t *pcm, + struct snd_pcm *pcm, int stream, - snd_pcm_file_t **rpcm_file) + struct snd_pcm_file **rpcm_file) { int err = 0; - snd_pcm_file_t *pcm_file; - snd_pcm_substream_t *substream; - snd_pcm_str_t *str; + struct snd_pcm_file *pcm_file; + struct snd_pcm_substream *substream; + struct snd_pcm_str *str; snd_assert(rpcm_file != NULL, return -EINVAL); *rpcm_file = NULL; @@ -2043,18 +2075,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) +{ + 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 cardnum = SNDRV_MINOR_CARD(iminor(inode)); - int device = SNDRV_MINOR_DEVICE(iminor(inode)); int err; - snd_pcm_t *pcm; - snd_pcm_file_t *pcm_file; + struct snd_pcm_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; @@ -2070,7 +2114,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) { @@ -2105,9 +2149,9 @@ static int snd_pcm_open(struct inode *inode, struct file *file) static int snd_pcm_release(struct inode *inode, struct file *file) { - snd_pcm_t *pcm; - snd_pcm_substream_t *substream; - snd_pcm_file_t *pcm_file; + struct snd_pcm *pcm; + struct snd_pcm_substream *substream; + struct snd_pcm_file *pcm_file; pcm_file = file->private_data; substream = pcm_file->substream; @@ -2125,9 +2169,10 @@ static int snd_pcm_release(struct inode *inode, struct file *file) return 0; } -static snd_pcm_sframes_t snd_pcm_playback_rewind(snd_pcm_substream_t *substream, snd_pcm_uframes_t frames) +static snd_pcm_sframes_t snd_pcm_playback_rewind(struct snd_pcm_substream *substream, + snd_pcm_uframes_t frames) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; snd_pcm_sframes_t appl_ptr; snd_pcm_sframes_t ret; snd_pcm_sframes_t hw_avail; @@ -2174,9 +2219,10 @@ static snd_pcm_sframes_t snd_pcm_playback_rewind(snd_pcm_substream_t *substream, return ret; } -static snd_pcm_sframes_t snd_pcm_capture_rewind(snd_pcm_substream_t *substream, snd_pcm_uframes_t frames) +static snd_pcm_sframes_t snd_pcm_capture_rewind(struct snd_pcm_substream *substream, + snd_pcm_uframes_t frames) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; snd_pcm_sframes_t appl_ptr; snd_pcm_sframes_t ret; snd_pcm_sframes_t hw_avail; @@ -2223,9 +2269,10 @@ static snd_pcm_sframes_t snd_pcm_capture_rewind(snd_pcm_substream_t *substream, return ret; } -static snd_pcm_sframes_t snd_pcm_playback_forward(snd_pcm_substream_t *substream, snd_pcm_uframes_t frames) +static snd_pcm_sframes_t snd_pcm_playback_forward(struct snd_pcm_substream *substream, + snd_pcm_uframes_t frames) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; snd_pcm_sframes_t appl_ptr; snd_pcm_sframes_t ret; snd_pcm_sframes_t avail; @@ -2273,9 +2320,10 @@ static snd_pcm_sframes_t snd_pcm_playback_forward(snd_pcm_substream_t *substream return ret; } -static snd_pcm_sframes_t snd_pcm_capture_forward(snd_pcm_substream_t *substream, snd_pcm_uframes_t frames) +static snd_pcm_sframes_t snd_pcm_capture_forward(struct snd_pcm_substream *substream, + snd_pcm_uframes_t frames) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; snd_pcm_sframes_t appl_ptr; snd_pcm_sframes_t ret; snd_pcm_sframes_t avail; @@ -2323,9 +2371,9 @@ static snd_pcm_sframes_t snd_pcm_capture_forward(snd_pcm_substream_t *substream, return ret; } -static int snd_pcm_hwsync(snd_pcm_substream_t *substream) +static int snd_pcm_hwsync(struct snd_pcm_substream *substream) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; int err; snd_pcm_stream_lock_irq(substream); @@ -2353,9 +2401,10 @@ static int snd_pcm_hwsync(snd_pcm_substream_t *substream) return err; } -static int snd_pcm_delay(snd_pcm_substream_t *substream, snd_pcm_sframes_t __user *res) +static int snd_pcm_delay(struct snd_pcm_substream *substream, + snd_pcm_sframes_t __user *res) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; int err; snd_pcm_sframes_t n = 0; @@ -2391,18 +2440,19 @@ static int snd_pcm_delay(snd_pcm_substream_t *substream, snd_pcm_sframes_t __use return err; } -static int snd_pcm_sync_ptr(snd_pcm_substream_t *substream, struct sndrv_pcm_sync_ptr __user *_sync_ptr) +static int snd_pcm_sync_ptr(struct snd_pcm_substream *substream, + struct snd_pcm_sync_ptr __user *_sync_ptr) { - snd_pcm_runtime_t *runtime = substream->runtime; - struct sndrv_pcm_sync_ptr sync_ptr; - volatile struct sndrv_pcm_mmap_status *status; - volatile struct sndrv_pcm_mmap_control *control; + struct snd_pcm_runtime *runtime = substream->runtime; + struct snd_pcm_sync_ptr sync_ptr; + volatile struct snd_pcm_mmap_status *status; + volatile struct snd_pcm_mmap_control *control; int err; memset(&sync_ptr, 0, sizeof(sync_ptr)); if (get_user(sync_ptr.flags, (unsigned __user *)&(_sync_ptr->flags))) return -EFAULT; - if (copy_from_user(&sync_ptr.c.control, &(_sync_ptr->c.control), sizeof(struct sndrv_pcm_mmap_control))) + if (copy_from_user(&sync_ptr.c.control, &(_sync_ptr->c.control), sizeof(struct snd_pcm_mmap_control))) return -EFAULT; status = runtime->status; control = runtime->control; @@ -2430,12 +2480,12 @@ static int snd_pcm_sync_ptr(snd_pcm_substream_t *substream, struct sndrv_pcm_syn return 0; } -static int snd_pcm_playback_ioctl1(snd_pcm_substream_t *substream, +static int snd_pcm_playback_ioctl1(struct snd_pcm_substream *substream, unsigned int cmd, void __user *arg); -static int snd_pcm_capture_ioctl1(snd_pcm_substream_t *substream, +static int snd_pcm_capture_ioctl1(struct snd_pcm_substream *substream, unsigned int cmd, void __user *arg); -static int snd_pcm_common_ioctl1(snd_pcm_substream_t *substream, +static int snd_pcm_common_ioctl1(struct snd_pcm_substream *substream, unsigned int cmd, void __user *arg) { snd_assert(substream != NULL, return -ENXIO); @@ -2479,10 +2529,12 @@ static int snd_pcm_common_ioctl1(snd_pcm_substream_t *substream, return snd_pcm_delay(substream, arg); case SNDRV_PCM_IOCTL_SYNC_PTR: return snd_pcm_sync_ptr(substream, arg); +#ifdef CONFIG_SND_SUPPORT_OLD_API case SNDRV_PCM_IOCTL_HW_REFINE_OLD: return snd_pcm_hw_refine_old_user(substream, arg); case SNDRV_PCM_IOCTL_HW_PARAMS_OLD: return snd_pcm_hw_params_old_user(substream, arg); +#endif case SNDRV_PCM_IOCTL_DRAIN: return snd_pcm_drain(substream); case SNDRV_PCM_IOCTL_DROP: @@ -2492,7 +2544,7 @@ static int snd_pcm_common_ioctl1(snd_pcm_substream_t *substream, return -ENOTTY; } -static int snd_pcm_playback_ioctl1(snd_pcm_substream_t *substream, +static int snd_pcm_playback_ioctl1(struct snd_pcm_substream *substream, unsigned int cmd, void __user *arg) { snd_assert(substream != NULL, return -ENXIO); @@ -2500,9 +2552,9 @@ static int snd_pcm_playback_ioctl1(snd_pcm_substream_t *substream, switch (cmd) { case SNDRV_PCM_IOCTL_WRITEI_FRAMES: { - snd_xferi_t xferi; - snd_xferi_t __user *_xferi = arg; - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_xferi xferi; + struct snd_xferi __user *_xferi = arg; + struct snd_pcm_runtime *runtime = substream->runtime; snd_pcm_sframes_t result; if (runtime->status->state == SNDRV_PCM_STATE_OPEN) return -EBADFD; @@ -2516,9 +2568,9 @@ static int snd_pcm_playback_ioctl1(snd_pcm_substream_t *substream, } case SNDRV_PCM_IOCTL_WRITEN_FRAMES: { - snd_xfern_t xfern; - snd_xfern_t __user *_xfern = arg; - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_xfern xfern; + struct snd_xfern __user *_xfern = arg; + struct snd_pcm_runtime *runtime = substream->runtime; void __user **bufs; snd_pcm_sframes_t result; if (runtime->status->state == SNDRV_PCM_STATE_OPEN) @@ -2579,7 +2631,7 @@ static int snd_pcm_playback_ioctl1(snd_pcm_substream_t *substream, return snd_pcm_common_ioctl1(substream, cmd, arg); } -static int snd_pcm_capture_ioctl1(snd_pcm_substream_t *substream, +static int snd_pcm_capture_ioctl1(struct snd_pcm_substream *substream, unsigned int cmd, void __user *arg) { snd_assert(substream != NULL, return -ENXIO); @@ -2587,9 +2639,9 @@ static int snd_pcm_capture_ioctl1(snd_pcm_substream_t *substream, switch (cmd) { case SNDRV_PCM_IOCTL_READI_FRAMES: { - snd_xferi_t xferi; - snd_xferi_t __user *_xferi = arg; - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_xferi xferi; + struct snd_xferi __user *_xferi = arg; + struct snd_pcm_runtime *runtime = substream->runtime; snd_pcm_sframes_t result; if (runtime->status->state == SNDRV_PCM_STATE_OPEN) return -EBADFD; @@ -2603,9 +2655,9 @@ static int snd_pcm_capture_ioctl1(snd_pcm_substream_t *substream, } case SNDRV_PCM_IOCTL_READN_FRAMES: { - snd_xfern_t xfern; - snd_xfern_t __user *_xfern = arg; - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_xfern xfern; + struct snd_xfern __user *_xfern = arg; + struct snd_pcm_runtime *runtime = substream->runtime; void *bufs; snd_pcm_sframes_t result; if (runtime->status->state == SNDRV_PCM_STATE_OPEN) @@ -2658,9 +2710,10 @@ static int snd_pcm_capture_ioctl1(snd_pcm_substream_t *substream, return snd_pcm_common_ioctl1(substream, cmd, arg); } -static long snd_pcm_playback_ioctl(struct file *file, unsigned int cmd, unsigned long arg) +static long snd_pcm_playback_ioctl(struct file *file, unsigned int cmd, + unsigned long arg) { - snd_pcm_file_t *pcm_file; + struct snd_pcm_file *pcm_file; pcm_file = file->private_data; @@ -2670,9 +2723,10 @@ static long snd_pcm_playback_ioctl(struct file *file, unsigned int cmd, unsigned return snd_pcm_playback_ioctl1(pcm_file->substream, cmd, (void __user *)arg); } -static long snd_pcm_capture_ioctl(struct file *file, unsigned int cmd, unsigned long arg) +static long snd_pcm_capture_ioctl(struct file *file, unsigned int cmd, + unsigned long arg) { - snd_pcm_file_t *pcm_file; + struct snd_pcm_file *pcm_file; pcm_file = file->private_data; @@ -2682,7 +2736,7 @@ static long snd_pcm_capture_ioctl(struct file *file, unsigned int cmd, unsigned return snd_pcm_capture_ioctl1(pcm_file->substream, cmd, (void __user *)arg); } -int snd_pcm_kernel_playback_ioctl(snd_pcm_substream_t *substream, +int snd_pcm_kernel_playback_ioctl(struct snd_pcm_substream *substream, unsigned int cmd, void *arg) { mm_segment_t fs; @@ -2694,7 +2748,7 @@ int snd_pcm_kernel_playback_ioctl(snd_pcm_substream_t *substream, return result; } -int snd_pcm_kernel_capture_ioctl(snd_pcm_substream_t *substream, +int snd_pcm_kernel_capture_ioctl(struct snd_pcm_substream *substream, unsigned int cmd, void *arg) { mm_segment_t fs; @@ -2706,7 +2760,7 @@ int snd_pcm_kernel_capture_ioctl(snd_pcm_substream_t *substream, return result; } -int snd_pcm_kernel_ioctl(snd_pcm_substream_t *substream, +int snd_pcm_kernel_ioctl(struct snd_pcm_substream *substream, unsigned int cmd, void *arg) { switch (substream->stream) { @@ -2719,11 +2773,12 @@ int snd_pcm_kernel_ioctl(snd_pcm_substream_t *substream, } } -static ssize_t snd_pcm_read(struct file *file, char __user *buf, size_t count, loff_t * offset) +static ssize_t snd_pcm_read(struct file *file, char __user *buf, size_t count, + loff_t * offset) { - snd_pcm_file_t *pcm_file; - snd_pcm_substream_t *substream; - snd_pcm_runtime_t *runtime; + struct snd_pcm_file *pcm_file; + struct snd_pcm_substream *substream; + struct snd_pcm_runtime *runtime; snd_pcm_sframes_t result; pcm_file = file->private_data; @@ -2741,11 +2796,12 @@ static ssize_t snd_pcm_read(struct file *file, char __user *buf, size_t count, l return result; } -static ssize_t snd_pcm_write(struct file *file, const char __user *buf, size_t count, loff_t * offset) +static ssize_t snd_pcm_write(struct file *file, const char __user *buf, + size_t count, loff_t * offset) { - snd_pcm_file_t *pcm_file; - snd_pcm_substream_t *substream; - snd_pcm_runtime_t *runtime; + struct snd_pcm_file *pcm_file; + struct snd_pcm_substream *substream; + struct snd_pcm_runtime *runtime; snd_pcm_sframes_t result; pcm_file = file->private_data; @@ -2772,9 +2828,9 @@ static ssize_t snd_pcm_readv(struct file *file, const struct iovec *_vector, unsigned long count, loff_t * offset) { - snd_pcm_file_t *pcm_file; - snd_pcm_substream_t *substream; - snd_pcm_runtime_t *runtime; + struct snd_pcm_file *pcm_file; + struct snd_pcm_substream *substream; + struct snd_pcm_runtime *runtime; snd_pcm_sframes_t result; unsigned long i; void __user **bufs; @@ -2806,9 +2862,9 @@ static ssize_t snd_pcm_readv(struct file *file, const struct iovec *_vector, static ssize_t snd_pcm_writev(struct file *file, const struct iovec *_vector, unsigned long count, loff_t * offset) { - snd_pcm_file_t *pcm_file; - snd_pcm_substream_t *substream; - snd_pcm_runtime_t *runtime; + struct snd_pcm_file *pcm_file; + struct snd_pcm_substream *substream; + struct snd_pcm_runtime *runtime; snd_pcm_sframes_t result; unsigned long i; void __user **bufs; @@ -2843,9 +2899,9 @@ static ssize_t snd_pcm_writev(struct file *file, const struct iovec *_vector, static unsigned int snd_pcm_playback_poll(struct file *file, poll_table * wait) { - snd_pcm_file_t *pcm_file; - snd_pcm_substream_t *substream; - snd_pcm_runtime_t *runtime; + struct snd_pcm_file *pcm_file; + struct snd_pcm_substream *substream; + struct snd_pcm_runtime *runtime; unsigned int mask; snd_pcm_uframes_t avail; @@ -2881,9 +2937,9 @@ static unsigned int snd_pcm_playback_poll(struct file *file, poll_table * wait) static unsigned int snd_pcm_capture_poll(struct file *file, poll_table * wait) { - snd_pcm_file_t *pcm_file; - snd_pcm_substream_t *substream; - snd_pcm_runtime_t *runtime; + struct snd_pcm_file *pcm_file; + struct snd_pcm_substream *substream; + struct snd_pcm_runtime *runtime; unsigned int mask; snd_pcm_uframes_t avail; @@ -2933,10 +2989,11 @@ static unsigned int snd_pcm_capture_poll(struct file *file, poll_table * wait) /* * mmap status record */ -static struct page * snd_pcm_mmap_status_nopage(struct vm_area_struct *area, unsigned long address, int *type) +static struct page * snd_pcm_mmap_status_nopage(struct vm_area_struct *area, + unsigned long address, int *type) { - snd_pcm_substream_t *substream = (snd_pcm_substream_t *)area->vm_private_data; - snd_pcm_runtime_t *runtime; + struct snd_pcm_substream *substream = area->vm_private_data; + struct snd_pcm_runtime *runtime; struct page * page; if (substream == NULL) @@ -2954,17 +3011,17 @@ static struct vm_operations_struct snd_pcm_vm_ops_status = .nopage = snd_pcm_mmap_status_nopage, }; -static int snd_pcm_mmap_status(snd_pcm_substream_t *substream, struct file *file, +static int snd_pcm_mmap_status(struct snd_pcm_substream *substream, struct file *file, struct vm_area_struct *area) { - snd_pcm_runtime_t *runtime; + struct snd_pcm_runtime *runtime; long size; if (!(area->vm_flags & VM_READ)) return -EINVAL; runtime = substream->runtime; snd_assert(runtime != NULL, return -EAGAIN); size = area->vm_end - area->vm_start; - if (size != PAGE_ALIGN(sizeof(snd_pcm_mmap_status_t))) + if (size != PAGE_ALIGN(sizeof(struct snd_pcm_mmap_status))) return -EINVAL; area->vm_ops = &snd_pcm_vm_ops_status; area->vm_private_data = substream; @@ -2975,10 +3032,11 @@ static int snd_pcm_mmap_status(snd_pcm_substream_t *substream, struct file *file /* * mmap control record */ -static struct page * snd_pcm_mmap_control_nopage(struct vm_area_struct *area, unsigned long address, int *type) +static struct page * snd_pcm_mmap_control_nopage(struct vm_area_struct *area, + unsigned long address, int *type) { - snd_pcm_substream_t *substream = (snd_pcm_substream_t *)area->vm_private_data; - snd_pcm_runtime_t *runtime; + struct snd_pcm_substream *substream = area->vm_private_data; + struct snd_pcm_runtime *runtime; struct page * page; if (substream == NULL) @@ -2996,17 +3054,17 @@ static struct vm_operations_struct snd_pcm_vm_ops_control = .nopage = snd_pcm_mmap_control_nopage, }; -static int snd_pcm_mmap_control(snd_pcm_substream_t *substream, struct file *file, +static int snd_pcm_mmap_control(struct snd_pcm_substream *substream, struct file *file, struct vm_area_struct *area) { - snd_pcm_runtime_t *runtime; + struct snd_pcm_runtime *runtime; long size; if (!(area->vm_flags & VM_READ)) return -EINVAL; runtime = substream->runtime; snd_assert(runtime != NULL, return -EAGAIN); size = area->vm_end - area->vm_start; - if (size != PAGE_ALIGN(sizeof(snd_pcm_mmap_control_t))) + if (size != PAGE_ALIGN(sizeof(struct snd_pcm_mmap_control))) return -EINVAL; area->vm_ops = &snd_pcm_vm_ops_control; area->vm_private_data = substream; @@ -3017,12 +3075,12 @@ static int snd_pcm_mmap_control(snd_pcm_substream_t *substream, struct file *fil /* * don't support mmap for status and control records. */ -static int snd_pcm_mmap_status(snd_pcm_substream_t *substream, struct file *file, +static int snd_pcm_mmap_status(struct snd_pcm_substream *substream, struct file *file, struct vm_area_struct *area) { return -ENXIO; } -static int snd_pcm_mmap_control(snd_pcm_substream_t *substream, struct file *file, +static int snd_pcm_mmap_control(struct snd_pcm_substream *substream, struct file *file, struct vm_area_struct *area) { return -ENXIO; @@ -3032,10 +3090,11 @@ static int snd_pcm_mmap_control(snd_pcm_substream_t *substream, struct file *fil /* * nopage callback for mmapping a RAM page */ -static struct page *snd_pcm_mmap_data_nopage(struct vm_area_struct *area, unsigned long address, int *type) +static struct page *snd_pcm_mmap_data_nopage(struct vm_area_struct *area, + unsigned long address, int *type) { - snd_pcm_substream_t *substream = (snd_pcm_substream_t *)area->vm_private_data; - snd_pcm_runtime_t *runtime; + struct snd_pcm_substream *substream = area->vm_private_data; + struct snd_pcm_runtime *runtime; unsigned long offset; struct page * page; void *vaddr; @@ -3074,7 +3133,8 @@ static struct vm_operations_struct snd_pcm_vm_ops_data = /* * mmap the DMA buffer on RAM */ -static int snd_pcm_default_mmap(snd_pcm_substream_t *substream, struct vm_area_struct *area) +static int snd_pcm_default_mmap(struct snd_pcm_substream *substream, + struct vm_area_struct *area) { area->vm_ops = &snd_pcm_vm_ops_data; area->vm_private_data = substream; @@ -3093,7 +3153,8 @@ static struct vm_operations_struct snd_pcm_vm_ops_data_mmio = .close = snd_pcm_mmap_data_close, }; -int snd_pcm_lib_mmap_iomem(snd_pcm_substream_t *substream, struct vm_area_struct *area) +int snd_pcm_lib_mmap_iomem(struct snd_pcm_substream *substream, + struct vm_area_struct *area) { long size; unsigned long offset; @@ -3118,10 +3179,10 @@ int snd_pcm_lib_mmap_iomem(snd_pcm_substream_t *substream, struct vm_area_struct /* * mmap DMA buffer */ -int snd_pcm_mmap_data(snd_pcm_substream_t *substream, struct file *file, +int snd_pcm_mmap_data(struct snd_pcm_substream *substream, struct file *file, struct vm_area_struct *area) { - snd_pcm_runtime_t *runtime; + struct snd_pcm_runtime *runtime; long size; unsigned long offset; size_t dma_bytes; @@ -3158,8 +3219,8 @@ int snd_pcm_mmap_data(snd_pcm_substream_t *substream, struct file *file, static int snd_pcm_mmap(struct file *file, struct vm_area_struct *area) { - snd_pcm_file_t * pcm_file; - snd_pcm_substream_t *substream; + struct snd_pcm_file * pcm_file; + struct snd_pcm_substream *substream; unsigned long offset; pcm_file = file->private_data; @@ -3184,9 +3245,9 @@ static int snd_pcm_mmap(struct file *file, struct vm_area_struct *area) static int snd_pcm_fasync(int fd, struct file * file, int on) { - snd_pcm_file_t * pcm_file; - snd_pcm_substream_t *substream; - snd_pcm_runtime_t *runtime; + struct snd_pcm_file * pcm_file; + struct snd_pcm_substream *substream; + struct snd_pcm_runtime *runtime; int err; pcm_file = file->private_data; @@ -3213,10 +3274,12 @@ static int snd_pcm_fasync(int fd, struct file * file, int on) * To be removed helpers to keep binary compatibility */ +#ifdef CONFIG_SND_SUPPORT_OLD_API #define __OLD_TO_NEW_MASK(x) ((x&7)|((x&0x07fffff8)<<5)) #define __NEW_TO_OLD_MASK(x) ((x&7)|((x&0xffffff00)>>5)) -static void snd_pcm_hw_convert_from_old_params(snd_pcm_hw_params_t *params, struct sndrv_pcm_hw_params_old *oparams) +static void snd_pcm_hw_convert_from_old_params(struct snd_pcm_hw_params *params, + struct snd_pcm_hw_params_old *oparams) { unsigned int i; @@ -3234,7 +3297,8 @@ static void snd_pcm_hw_convert_from_old_params(snd_pcm_hw_params_t *params, stru params->fifo_size = oparams->fifo_size; } -static void snd_pcm_hw_convert_to_old_params(struct sndrv_pcm_hw_params_old *oparams, snd_pcm_hw_params_t *params) +static void snd_pcm_hw_convert_to_old_params(struct snd_pcm_hw_params_old *oparams, + struct snd_pcm_hw_params *params) { unsigned int i; @@ -3252,10 +3316,11 @@ static void snd_pcm_hw_convert_to_old_params(struct sndrv_pcm_hw_params_old *opa oparams->fifo_size = params->fifo_size; } -static int snd_pcm_hw_refine_old_user(snd_pcm_substream_t * substream, struct sndrv_pcm_hw_params_old __user * _oparams) +static int snd_pcm_hw_refine_old_user(struct snd_pcm_substream *substream, + struct snd_pcm_hw_params_old __user * _oparams) { - snd_pcm_hw_params_t *params; - struct sndrv_pcm_hw_params_old *oparams = NULL; + struct snd_pcm_hw_params *params; + struct snd_pcm_hw_params_old *oparams = NULL; int err; params = kmalloc(sizeof(*params), GFP_KERNEL); @@ -3286,10 +3351,11 @@ out: return err; } -static int snd_pcm_hw_params_old_user(snd_pcm_substream_t * substream, struct sndrv_pcm_hw_params_old __user * _oparams) +static int snd_pcm_hw_params_old_user(struct snd_pcm_substream *substream, + struct snd_pcm_hw_params_old __user * _oparams) { - snd_pcm_hw_params_t *params; - struct sndrv_pcm_hw_params_old *oparams = NULL; + struct snd_pcm_hw_params *params; + struct snd_pcm_hw_params_old *oparams = NULL; int err; params = kmalloc(sizeof(*params), GFP_KERNEL); @@ -3318,45 +3384,35 @@ out: kfree(oparams); return err; } +#endif /* CONFIG_SND_SUPPORT_OLD_API */ /* * 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, -}; - -snd_minor_t 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_playback_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_capture_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/pcm_timer.c b/sound/core/pcm_timer.c index 884eaea31fe..d94ed16d21e 100644 --- a/sound/core/pcm_timer.c +++ b/sound/core/pcm_timer.c @@ -45,10 +45,10 @@ static unsigned long gcd(unsigned long a, unsigned long b) return b; } -void snd_pcm_timer_resolution_change(snd_pcm_substream_t *substream) +void snd_pcm_timer_resolution_change(struct snd_pcm_substream *substream) { unsigned long rate, mult, fsize, l, post; - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; mult = 1000000000; rate = runtime->rate; @@ -74,18 +74,18 @@ void snd_pcm_timer_resolution_change(snd_pcm_substream_t *substream) runtime->timer_resolution = (mult * fsize / rate) * post; } -static unsigned long snd_pcm_timer_resolution(snd_timer_t * timer) +static unsigned long snd_pcm_timer_resolution(struct snd_timer * timer) { - snd_pcm_substream_t * substream; + struct snd_pcm_substream *substream; substream = timer->private_data; return substream->runtime ? substream->runtime->timer_resolution : 0; } -static int snd_pcm_timer_start(snd_timer_t * timer) +static int snd_pcm_timer_start(struct snd_timer * timer) { unsigned long flags; - snd_pcm_substream_t * substream; + struct snd_pcm_substream *substream; substream = snd_timer_chip(timer); spin_lock_irqsave(&substream->timer_lock, flags); @@ -94,10 +94,10 @@ static int snd_pcm_timer_start(snd_timer_t * timer) return 0; } -static int snd_pcm_timer_stop(snd_timer_t * timer) +static int snd_pcm_timer_stop(struct snd_timer * timer) { unsigned long flags; - snd_pcm_substream_t * substream; + struct snd_pcm_substream *substream; substream = snd_timer_chip(timer); spin_lock_irqsave(&substream->timer_lock, flags); @@ -106,7 +106,7 @@ static int snd_pcm_timer_stop(snd_timer_t * timer) return 0; } -static struct _snd_timer_hardware snd_pcm_timer = +static struct snd_timer_hardware snd_pcm_timer = { .flags = SNDRV_TIMER_HW_AUTO | SNDRV_TIMER_HW_SLAVE, .resolution = 0, @@ -120,16 +120,16 @@ static struct _snd_timer_hardware snd_pcm_timer = * Init functions */ -static void snd_pcm_timer_free(snd_timer_t *timer) +static void snd_pcm_timer_free(struct snd_timer *timer) { - snd_pcm_substream_t *substream = timer->private_data; + struct snd_pcm_substream *substream = timer->private_data; substream->timer = NULL; } -void snd_pcm_timer_init(snd_pcm_substream_t *substream) +void snd_pcm_timer_init(struct snd_pcm_substream *substream) { - snd_timer_id_t tid; - snd_timer_t *timer; + struct snd_timer_id tid; + struct snd_timer *timer; tid.dev_sclass = SNDRV_TIMER_SCLASS_NONE; tid.dev_class = SNDRV_TIMER_CLASS_PCM; @@ -152,7 +152,7 @@ void snd_pcm_timer_init(snd_pcm_substream_t *substream) substream->timer = timer; } -void snd_pcm_timer_done(snd_pcm_substream_t *substream) +void snd_pcm_timer_done(struct snd_pcm_substream *substream) { if (substream->timer) { snd_device_free(substream->pcm->card, substream->timer); diff --git a/sound/core/rawmidi.c b/sound/core/rawmidi.c index d033e61c05c..d4d124e2192 100644 --- a/sound/core/rawmidi.c +++ b/sound/core/rawmidi.c @@ -50,16 +50,28 @@ module_param_array(amidi_map, int, NULL, 0444); MODULE_PARM_DESC(amidi_map, "Raw MIDI device number assigned to 2nd OSS device."); #endif /* CONFIG_SND_OSSEMUL */ -static int snd_rawmidi_free(snd_rawmidi_t *rawmidi); -static int snd_rawmidi_dev_free(snd_device_t *device); -static int snd_rawmidi_dev_register(snd_device_t *device); -static int snd_rawmidi_dev_disconnect(snd_device_t *device); -static int snd_rawmidi_dev_unregister(snd_device_t *device); - -static snd_rawmidi_t *snd_rawmidi_devices[SNDRV_CARDS * SNDRV_RAWMIDI_DEVICES]; +static int snd_rawmidi_free(struct snd_rawmidi *rawmidi); +static int snd_rawmidi_dev_free(struct snd_device *device); +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 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)) { @@ -72,34 +84,35 @@ static inline unsigned short snd_rawmidi_file_flags(struct file *file) } } -static inline int snd_rawmidi_ready(snd_rawmidi_substream_t * substream) +static inline int snd_rawmidi_ready(struct snd_rawmidi_substream *substream) { - snd_rawmidi_runtime_t *runtime = substream->runtime; + struct snd_rawmidi_runtime *runtime = substream->runtime; return runtime->avail >= runtime->avail_min; } -static inline int snd_rawmidi_ready_append(snd_rawmidi_substream_t * substream, size_t count) +static inline int snd_rawmidi_ready_append(struct snd_rawmidi_substream *substream, + size_t count) { - snd_rawmidi_runtime_t *runtime = substream->runtime; + struct snd_rawmidi_runtime *runtime = substream->runtime; return runtime->avail >= runtime->avail_min && (!substream->append || runtime->avail >= count); } static void snd_rawmidi_input_event_tasklet(unsigned long data) { - snd_rawmidi_substream_t *substream = (snd_rawmidi_substream_t *)data; + struct snd_rawmidi_substream *substream = (struct snd_rawmidi_substream *)data; substream->runtime->event(substream); } static void snd_rawmidi_output_trigger_tasklet(unsigned long data) { - snd_rawmidi_substream_t *substream = (snd_rawmidi_substream_t *)data; + struct snd_rawmidi_substream *substream = (struct snd_rawmidi_substream *)data; substream->ops->trigger(substream, 1); } -static int snd_rawmidi_runtime_create(snd_rawmidi_substream_t * substream) +static int snd_rawmidi_runtime_create(struct snd_rawmidi_substream *substream) { - snd_rawmidi_runtime_t *runtime; + struct snd_rawmidi_runtime *runtime; if ((runtime = kzalloc(sizeof(*runtime), GFP_KERNEL)) == NULL) return -ENOMEM; @@ -129,9 +142,9 @@ static int snd_rawmidi_runtime_create(snd_rawmidi_substream_t * substream) return 0; } -static int snd_rawmidi_runtime_free(snd_rawmidi_substream_t * substream) +static int snd_rawmidi_runtime_free(struct snd_rawmidi_substream *substream) { - snd_rawmidi_runtime_t *runtime = substream->runtime; + struct snd_rawmidi_runtime *runtime = substream->runtime; kfree(runtime->buffer); kfree(runtime); @@ -139,7 +152,7 @@ static int snd_rawmidi_runtime_free(snd_rawmidi_substream_t * substream) return 0; } -static inline void snd_rawmidi_output_trigger(snd_rawmidi_substream_t * substream, int up) +static inline void snd_rawmidi_output_trigger(struct snd_rawmidi_substream *substream,int up) { if (up) { tasklet_hi_schedule(&substream->runtime->tasklet); @@ -149,17 +162,17 @@ static inline void snd_rawmidi_output_trigger(snd_rawmidi_substream_t * substrea } } -static void snd_rawmidi_input_trigger(snd_rawmidi_substream_t * substream, int up) +static void snd_rawmidi_input_trigger(struct snd_rawmidi_substream *substream, int up) { substream->ops->trigger(substream, up); if (!up && substream->runtime->event) tasklet_kill(&substream->runtime->tasklet); } -int snd_rawmidi_drop_output(snd_rawmidi_substream_t * substream) +int snd_rawmidi_drop_output(struct snd_rawmidi_substream *substream) { unsigned long flags; - snd_rawmidi_runtime_t *runtime = substream->runtime; + struct snd_rawmidi_runtime *runtime = substream->runtime; snd_rawmidi_output_trigger(substream, 0); runtime->drain = 0; @@ -170,11 +183,11 @@ int snd_rawmidi_drop_output(snd_rawmidi_substream_t * substream) return 0; } -int snd_rawmidi_drain_output(snd_rawmidi_substream_t * substream) +int snd_rawmidi_drain_output(struct snd_rawmidi_substream *substream) { int err; long timeout; - snd_rawmidi_runtime_t *runtime = substream->runtime; + struct snd_rawmidi_runtime *runtime = substream->runtime; err = 0; runtime->drain = 1; @@ -199,10 +212,10 @@ int snd_rawmidi_drain_output(snd_rawmidi_substream_t * substream) return err; } -int snd_rawmidi_drain_input(snd_rawmidi_substream_t * substream) +int snd_rawmidi_drain_input(struct snd_rawmidi_substream *substream) { unsigned long flags; - snd_rawmidi_runtime_t *runtime = substream->runtime; + struct snd_rawmidi_runtime *runtime = substream->runtime; snd_rawmidi_input_trigger(substream, 0); runtime->drain = 0; @@ -213,18 +226,20 @@ int snd_rawmidi_drain_input(snd_rawmidi_substream_t * substream) return 0; } -int snd_rawmidi_kernel_open(int cardnum, int device, int subdevice, - int mode, snd_rawmidi_file_t * rfile) +int snd_rawmidi_kernel_open(struct snd_card *card, int device, int subdevice, + int mode, struct snd_rawmidi_file * rfile) { - snd_rawmidi_t *rmidi; + struct snd_rawmidi *rmidi; struct list_head *list1, *list2; - snd_rawmidi_substream_t *sinput = NULL, *soutput = NULL; - snd_rawmidi_runtime_t *input = NULL, *output = NULL; + struct snd_rawmidi_substream *sinput = NULL, *soutput = NULL; + struct snd_rawmidi_runtime *input = NULL, *output = NULL; int err; 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; @@ -275,7 +290,7 @@ int snd_rawmidi_kernel_open(int cardnum, int device, int subdevice, } break; } - sinput = list_entry(list1, snd_rawmidi_substream_t, list); + sinput = list_entry(list1, struct snd_rawmidi_substream, list); if ((mode & SNDRV_RAWMIDI_LFLG_INPUT) && sinput->opened) goto __nexti; if (subdevice < 0 || (subdevice >= 0 && subdevice == sinput->number)) @@ -293,7 +308,7 @@ int snd_rawmidi_kernel_open(int cardnum, int device, int subdevice, } break; } - soutput = list_entry(list2, snd_rawmidi_substream_t, list); + soutput = list_entry(list2, struct snd_rawmidi_substream, list); if (mode & SNDRV_RAWMIDI_LFLG_OUTPUT) { if (mode & SNDRV_RAWMIDI_LFLG_APPEND) { if (soutput->opened && !soutput->append) @@ -367,39 +382,29 @@ 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; - snd_card_t *card; - int device, subdevice; + struct snd_card *card; + int subdevice; unsigned short fflags; int err; - snd_rawmidi_t *rmidi; - snd_rawmidi_file_t *rawmidi_file; + struct snd_rawmidi *rmidi; + struct snd_rawmidi_file *rawmidi_file; wait_queue_t wait; struct list_head *list; - snd_ctl_file_t *kctl; + 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; @@ -429,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) { @@ -465,11 +471,11 @@ static int snd_rawmidi_open(struct inode *inode, struct file *file) return err; } -int snd_rawmidi_kernel_release(snd_rawmidi_file_t * rfile) +int snd_rawmidi_kernel_release(struct snd_rawmidi_file * rfile) { - snd_rawmidi_t *rmidi; - snd_rawmidi_substream_t *substream; - snd_rawmidi_runtime_t *runtime; + struct snd_rawmidi *rmidi; + struct snd_rawmidi_substream *substream; + struct snd_rawmidi_runtime *runtime; snd_assert(rfile != NULL, return -ENXIO); snd_assert(rfile->input != NULL || rfile->output != NULL, return -ENXIO); @@ -515,8 +521,8 @@ int snd_rawmidi_kernel_release(snd_rawmidi_file_t * rfile) static int snd_rawmidi_release(struct inode *inode, struct file *file) { - snd_rawmidi_file_t *rfile; - snd_rawmidi_t *rmidi; + struct snd_rawmidi_file *rfile; + struct snd_rawmidi *rmidi; int err; rfile = file->private_data; @@ -528,9 +534,10 @@ static int snd_rawmidi_release(struct inode *inode, struct file *file) return err; } -int snd_rawmidi_info(snd_rawmidi_substream_t *substream, snd_rawmidi_info_t *info) +static int snd_rawmidi_info(struct snd_rawmidi_substream *substream, + struct snd_rawmidi_info *info) { - snd_rawmidi_t *rmidi; + struct snd_rawmidi *rmidi; if (substream == NULL) return -ENODEV; @@ -550,26 +557,30 @@ int snd_rawmidi_info(snd_rawmidi_substream_t *substream, snd_rawmidi_info_t *inf return 0; } -static int snd_rawmidi_info_user(snd_rawmidi_substream_t *substream, snd_rawmidi_info_t __user * _info) +static int snd_rawmidi_info_user(struct snd_rawmidi_substream *substream, + struct snd_rawmidi_info __user * _info) { - snd_rawmidi_info_t info; + struct snd_rawmidi_info info; int err; if ((err = snd_rawmidi_info(substream, &info)) < 0) return err; - if (copy_to_user(_info, &info, sizeof(snd_rawmidi_info_t))) + if (copy_to_user(_info, &info, sizeof(struct snd_rawmidi_info))) return -EFAULT; return 0; } -int snd_rawmidi_info_select(snd_card_t *card, snd_rawmidi_info_t *info) +int snd_rawmidi_info_select(struct snd_card *card, struct snd_rawmidi_info *info) { - snd_rawmidi_t *rmidi; - snd_rawmidi_str_t *pstr; - snd_rawmidi_substream_t *substream; + struct snd_rawmidi *rmidi; + struct snd_rawmidi_str *pstr; + struct snd_rawmidi_substream *substream; struct list_head *list; - if (info->device >= SNDRV_RAWMIDI_DEVICES) + + down(®ister_mutex); + rmidi = snd_rawmidi_search(card, info->device); + up(®ister_mutex); + if (!rmidi) return -ENXIO; - rmidi = snd_rawmidi_devices[card->number * SNDRV_RAWMIDI_DEVICES + info->device]; if (info->stream < 0 || info->stream > 1) return -EINVAL; pstr = &rmidi->streams[info->stream]; @@ -578,18 +589,18 @@ int snd_rawmidi_info_select(snd_card_t *card, snd_rawmidi_info_t *info) if (info->subdevice >= pstr->substream_count) return -ENXIO; list_for_each(list, &pstr->substreams) { - substream = list_entry(list, snd_rawmidi_substream_t, list); + substream = list_entry(list, struct snd_rawmidi_substream, list); if ((unsigned int)substream->number == info->subdevice) return snd_rawmidi_info(substream, info); } return -ENXIO; } -static int snd_rawmidi_info_select_user(snd_card_t *card, - snd_rawmidi_info_t __user *_info) +static int snd_rawmidi_info_select_user(struct snd_card *card, + struct snd_rawmidi_info __user *_info) { int err; - snd_rawmidi_info_t info; + struct snd_rawmidi_info info; if (get_user(info.device, &_info->device)) return -EFAULT; if (get_user(info.stream, &_info->stream)) @@ -598,16 +609,16 @@ static int snd_rawmidi_info_select_user(snd_card_t *card, return -EFAULT; if ((err = snd_rawmidi_info_select(card, &info)) < 0) return err; - if (copy_to_user(_info, &info, sizeof(snd_rawmidi_info_t))) + if (copy_to_user(_info, &info, sizeof(struct snd_rawmidi_info))) return -EFAULT; return 0; } -int snd_rawmidi_output_params(snd_rawmidi_substream_t * substream, - snd_rawmidi_params_t * params) +int snd_rawmidi_output_params(struct snd_rawmidi_substream *substream, + struct snd_rawmidi_params * params) { char *newbuf; - snd_rawmidi_runtime_t *runtime = substream->runtime; + struct snd_rawmidi_runtime *runtime = substream->runtime; if (substream->append && substream->use_count > 1) return -EBUSY; @@ -624,17 +635,18 @@ int snd_rawmidi_output_params(snd_rawmidi_substream_t * substream, kfree(runtime->buffer); runtime->buffer = newbuf; runtime->buffer_size = params->buffer_size; + runtime->avail = runtime->buffer_size; } runtime->avail_min = params->avail_min; substream->active_sensing = !params->no_active_sensing; return 0; } -int snd_rawmidi_input_params(snd_rawmidi_substream_t * substream, - snd_rawmidi_params_t * params) +int snd_rawmidi_input_params(struct snd_rawmidi_substream *substream, + struct snd_rawmidi_params * params) { char *newbuf; - snd_rawmidi_runtime_t *runtime = substream->runtime; + struct snd_rawmidi_runtime *runtime = substream->runtime; snd_rawmidi_drain_input(substream); if (params->buffer_size < 32 || params->buffer_size > 1024L * 1024L) { @@ -654,10 +666,10 @@ int snd_rawmidi_input_params(snd_rawmidi_substream_t * substream, return 0; } -static int snd_rawmidi_output_status(snd_rawmidi_substream_t * substream, - snd_rawmidi_status_t * status) +static int snd_rawmidi_output_status(struct snd_rawmidi_substream *substream, + struct snd_rawmidi_status * status) { - snd_rawmidi_runtime_t *runtime = substream->runtime; + struct snd_rawmidi_runtime *runtime = substream->runtime; memset(status, 0, sizeof(*status)); status->stream = SNDRV_RAWMIDI_STREAM_OUTPUT; @@ -667,10 +679,10 @@ static int snd_rawmidi_output_status(snd_rawmidi_substream_t * substream, return 0; } -static int snd_rawmidi_input_status(snd_rawmidi_substream_t * substream, - snd_rawmidi_status_t * status) +static int snd_rawmidi_input_status(struct snd_rawmidi_substream *substream, + struct snd_rawmidi_status * status) { - snd_rawmidi_runtime_t *runtime = substream->runtime; + struct snd_rawmidi_runtime *runtime = substream->runtime; memset(status, 0, sizeof(*status)); status->stream = SNDRV_RAWMIDI_STREAM_INPUT; @@ -684,7 +696,7 @@ static int snd_rawmidi_input_status(snd_rawmidi_substream_t * substream, static long snd_rawmidi_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { - snd_rawmidi_file_t *rfile; + struct snd_rawmidi_file *rfile; void __user *argp = (void __user *)arg; rfile = file->private_data; @@ -695,8 +707,8 @@ static long snd_rawmidi_ioctl(struct file *file, unsigned int cmd, unsigned long return put_user(SNDRV_RAWMIDI_VERSION, (int __user *)argp) ? -EFAULT : 0; case SNDRV_RAWMIDI_IOCTL_INFO: { - snd_rawmidi_stream_t stream; - snd_rawmidi_info_t __user *info = argp; + int stream; + struct snd_rawmidi_info __user *info = argp; if (get_user(stream, &info->stream)) return -EFAULT; switch (stream) { @@ -710,8 +722,8 @@ static long snd_rawmidi_ioctl(struct file *file, unsigned int cmd, unsigned long } case SNDRV_RAWMIDI_IOCTL_PARAMS: { - snd_rawmidi_params_t params; - if (copy_from_user(¶ms, argp, sizeof(snd_rawmidi_params_t))) + struct snd_rawmidi_params params; + if (copy_from_user(¶ms, argp, sizeof(struct snd_rawmidi_params))) return -EFAULT; switch (params.stream) { case SNDRV_RAWMIDI_STREAM_OUTPUT: @@ -729,8 +741,8 @@ static long snd_rawmidi_ioctl(struct file *file, unsigned int cmd, unsigned long case SNDRV_RAWMIDI_IOCTL_STATUS: { int err = 0; - snd_rawmidi_status_t status; - if (copy_from_user(&status, argp, sizeof(snd_rawmidi_status_t))) + struct snd_rawmidi_status status; + if (copy_from_user(&status, argp, sizeof(struct snd_rawmidi_status))) return -EFAULT; switch (status.stream) { case SNDRV_RAWMIDI_STREAM_OUTPUT: @@ -748,7 +760,7 @@ static long snd_rawmidi_ioctl(struct file *file, unsigned int cmd, unsigned long } if (err < 0) return err; - if (copy_to_user(argp, &status, sizeof(snd_rawmidi_status_t))) + if (copy_to_user(argp, &status, sizeof(struct snd_rawmidi_status))) return -EFAULT; return 0; } @@ -792,15 +804,13 @@ static long snd_rawmidi_ioctl(struct file *file, unsigned int cmd, unsigned long return -ENOTTY; } -static int snd_rawmidi_control_ioctl(snd_card_t * card, - snd_ctl_file_t * control, +static int snd_rawmidi_control_ioctl(struct snd_card *card, + struct snd_ctl_file *control, unsigned int cmd, 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: { @@ -808,14 +818,16 @@ static int snd_rawmidi_control_ioctl(snd_card_t * 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; @@ -845,11 +857,12 @@ static int snd_rawmidi_control_ioctl(snd_card_t * card, * * Returns the size of read data, or a negative error code on failure. */ -int snd_rawmidi_receive(snd_rawmidi_substream_t * substream, const unsigned char *buffer, int count) +int snd_rawmidi_receive(struct snd_rawmidi_substream *substream, + const unsigned char *buffer, int count) { unsigned long flags; int result = 0, count1; - snd_rawmidi_runtime_t *runtime = substream->runtime; + struct snd_rawmidi_runtime *runtime = substream->runtime; if (runtime->buffer == NULL) { snd_printd("snd_rawmidi_receive: input is not active!!!\n"); @@ -904,12 +917,12 @@ int snd_rawmidi_receive(snd_rawmidi_substream_t * substream, const unsigned char return result; } -static long snd_rawmidi_kernel_read1(snd_rawmidi_substream_t *substream, +static long snd_rawmidi_kernel_read1(struct snd_rawmidi_substream *substream, unsigned char *buf, long count, int kernel) { unsigned long flags; long result = 0, count1; - snd_rawmidi_runtime_t *runtime = substream->runtime; + struct snd_rawmidi_runtime *runtime = substream->runtime; while (count > 0 && runtime->avail) { count1 = runtime->buffer_size - runtime->appl_ptr; @@ -938,19 +951,21 @@ static long snd_rawmidi_kernel_read1(snd_rawmidi_substream_t *substream, return result; } -long snd_rawmidi_kernel_read(snd_rawmidi_substream_t *substream, unsigned char *buf, long count) +long snd_rawmidi_kernel_read(struct snd_rawmidi_substream *substream, + unsigned char *buf, long count) { snd_rawmidi_input_trigger(substream, 1); return snd_rawmidi_kernel_read1(substream, buf, count, 1); } -static ssize_t snd_rawmidi_read(struct file *file, char __user *buf, size_t count, loff_t *offset) +static ssize_t snd_rawmidi_read(struct file *file, char __user *buf, size_t count, + loff_t *offset) { long result; int count1; - snd_rawmidi_file_t *rfile; - snd_rawmidi_substream_t *substream; - snd_rawmidi_runtime_t *runtime; + struct snd_rawmidi_file *rfile; + struct snd_rawmidi_substream *substream; + struct snd_rawmidi_runtime *runtime; rfile = file->private_data; substream = rfile->input; @@ -998,9 +1013,9 @@ static ssize_t snd_rawmidi_read(struct file *file, char __user *buf, size_t coun * * Returns 1 if the internal output buffer is empty, 0 if not. */ -int snd_rawmidi_transmit_empty(snd_rawmidi_substream_t * substream) +int snd_rawmidi_transmit_empty(struct snd_rawmidi_substream *substream) { - snd_rawmidi_runtime_t *runtime = substream->runtime; + struct snd_rawmidi_runtime *runtime = substream->runtime; int result; unsigned long flags; @@ -1028,11 +1043,12 @@ int snd_rawmidi_transmit_empty(snd_rawmidi_substream_t * substream) * * Returns the size of copied data, or a negative error code on failure. */ -int snd_rawmidi_transmit_peek(snd_rawmidi_substream_t * substream, unsigned char *buffer, int count) +int snd_rawmidi_transmit_peek(struct snd_rawmidi_substream *substream, + unsigned char *buffer, int count) { unsigned long flags; int result, count1; - snd_rawmidi_runtime_t *runtime = substream->runtime; + struct snd_rawmidi_runtime *runtime = substream->runtime; if (runtime->buffer == NULL) { snd_printd("snd_rawmidi_transmit_peek: output is not active!!!\n"); @@ -1079,10 +1095,10 @@ int snd_rawmidi_transmit_peek(snd_rawmidi_substream_t * substream, unsigned char * * Returns the advanced size if successful, or a negative error code on failure. */ -int snd_rawmidi_transmit_ack(snd_rawmidi_substream_t * substream, int count) +int snd_rawmidi_transmit_ack(struct snd_rawmidi_substream *substream, int count) { unsigned long flags; - snd_rawmidi_runtime_t *runtime = substream->runtime; + struct snd_rawmidi_runtime *runtime = substream->runtime; if (runtime->buffer == NULL) { snd_printd("snd_rawmidi_transmit_ack: output is not active!!!\n"); @@ -1112,7 +1128,8 @@ int snd_rawmidi_transmit_ack(snd_rawmidi_substream_t * substream, int count) * * Returns the copied size if successful, or a negative error code on failure. */ -int snd_rawmidi_transmit(snd_rawmidi_substream_t * substream, unsigned char *buffer, int count) +int snd_rawmidi_transmit(struct snd_rawmidi_substream *substream, + unsigned char *buffer, int count) { count = snd_rawmidi_transmit_peek(substream, buffer, count); if (count < 0) @@ -1120,11 +1137,12 @@ int snd_rawmidi_transmit(snd_rawmidi_substream_t * substream, unsigned char *buf return snd_rawmidi_transmit_ack(substream, count); } -static long snd_rawmidi_kernel_write1(snd_rawmidi_substream_t * substream, const unsigned char *buf, long count, int kernel) +static long snd_rawmidi_kernel_write1(struct snd_rawmidi_substream *substream, + const unsigned char *buf, long count, int kernel) { unsigned long flags; long count1, result; - snd_rawmidi_runtime_t *runtime = substream->runtime; + struct snd_rawmidi_runtime *runtime = substream->runtime; snd_assert(buf != NULL, return -EINVAL); snd_assert(runtime->buffer != NULL, return -EINVAL); @@ -1170,18 +1188,20 @@ static long snd_rawmidi_kernel_write1(snd_rawmidi_substream_t * substream, const return result; } -long snd_rawmidi_kernel_write(snd_rawmidi_substream_t * substream, const unsigned char *buf, long count) +long snd_rawmidi_kernel_write(struct snd_rawmidi_substream *substream, + const unsigned char *buf, long count) { return snd_rawmidi_kernel_write1(substream, buf, count, 1); } -static ssize_t snd_rawmidi_write(struct file *file, const char __user *buf, size_t count, loff_t *offset) +static ssize_t snd_rawmidi_write(struct file *file, const char __user *buf, + size_t count, loff_t *offset) { long result, timeout; int count1; - snd_rawmidi_file_t *rfile; - snd_rawmidi_runtime_t *runtime; - snd_rawmidi_substream_t *substream; + struct snd_rawmidi_file *rfile; + struct snd_rawmidi_runtime *runtime; + struct snd_rawmidi_substream *substream; rfile = file->private_data; substream = rfile->output; @@ -1246,8 +1266,8 @@ static ssize_t snd_rawmidi_write(struct file *file, const char __user *buf, size static unsigned int snd_rawmidi_poll(struct file *file, poll_table * wait) { - snd_rawmidi_file_t *rfile; - snd_rawmidi_runtime_t *runtime; + struct snd_rawmidi_file *rfile; + struct snd_rawmidi_runtime *runtime; unsigned int mask; rfile = file->private_data; @@ -1284,12 +1304,12 @@ static unsigned int snd_rawmidi_poll(struct file *file, poll_table * wait) */ -static void snd_rawmidi_proc_info_read(snd_info_entry_t *entry, - snd_info_buffer_t * buffer) +static void snd_rawmidi_proc_info_read(struct snd_info_entry *entry, + struct snd_info_buffer *buffer) { - snd_rawmidi_t *rmidi; - snd_rawmidi_substream_t *substream; - snd_rawmidi_runtime_t *runtime; + struct snd_rawmidi *rmidi; + struct snd_rawmidi_substream *substream; + struct snd_rawmidi_runtime *runtime; struct list_head *list; rmidi = entry->private_data; @@ -1297,7 +1317,7 @@ static void snd_rawmidi_proc_info_read(snd_info_entry_t *entry, down(&rmidi->open_mutex); if (rmidi->info_flags & SNDRV_RAWMIDI_INFO_OUTPUT) { list_for_each(list, &rmidi->streams[SNDRV_RAWMIDI_STREAM_OUTPUT].substreams) { - substream = list_entry(list, snd_rawmidi_substream_t, list); + substream = list_entry(list, struct snd_rawmidi_substream, list); snd_iprintf(buffer, "Output %d\n" " Tx bytes : %lu\n", @@ -1317,7 +1337,7 @@ static void snd_rawmidi_proc_info_read(snd_info_entry_t *entry, } if (rmidi->info_flags & SNDRV_RAWMIDI_INFO_INPUT) { list_for_each(list, &rmidi->streams[SNDRV_RAWMIDI_STREAM_INPUT].substreams) { - substream = list_entry(list, snd_rawmidi_substream_t, list); + substream = list_entry(list, struct snd_rawmidi_substream, list); snd_iprintf(buffer, "Input %d\n" " Rx bytes : %lu\n", @@ -1354,25 +1374,21 @@ static struct file_operations snd_rawmidi_f_ops = .compat_ioctl = snd_rawmidi_ioctl_compat, }; -static snd_minor_t snd_rawmidi_reg = -{ - .comment = "raw midi", - .f_ops = &snd_rawmidi_f_ops, -}; - -static int snd_rawmidi_alloc_substreams(snd_rawmidi_t *rmidi, - snd_rawmidi_str_t *stream, +static int snd_rawmidi_alloc_substreams(struct snd_rawmidi *rmidi, + struct snd_rawmidi_str *stream, int direction, int count) { - snd_rawmidi_substream_t *substream; + struct snd_rawmidi_substream *substream; int idx; INIT_LIST_HEAD(&stream->substreams); for (idx = 0; idx < count; idx++) { substream = kzalloc(sizeof(*substream), GFP_KERNEL); - if (substream == NULL) + if (substream == NULL) { + snd_printk(KERN_ERR "rawmidi: cannot allocate substream\n"); return -ENOMEM; + } substream->stream = direction; substream->number = idx; substream->rmidi = rmidi; @@ -1397,13 +1413,13 @@ static int snd_rawmidi_alloc_substreams(snd_rawmidi_t *rmidi, * * Returns zero if successful, or a negative error code on failure. */ -int snd_rawmidi_new(snd_card_t * card, char *id, int device, +int snd_rawmidi_new(struct snd_card *card, char *id, int device, int output_count, int input_count, - snd_rawmidi_t ** rrawmidi) + struct snd_rawmidi ** rrawmidi) { - snd_rawmidi_t *rmidi; + struct snd_rawmidi *rmidi; int err; - static snd_device_ops_t ops = { + static struct snd_device_ops ops = { .dev_free = snd_rawmidi_dev_free, .dev_register = snd_rawmidi_dev_register, .dev_disconnect = snd_rawmidi_dev_disconnect, @@ -1414,19 +1430,27 @@ int snd_rawmidi_new(snd_card_t * card, char *id, int device, *rrawmidi = NULL; snd_assert(card != NULL, return -ENXIO); rmidi = kzalloc(sizeof(*rmidi), GFP_KERNEL); - if (rmidi == NULL) + if (rmidi == NULL) { + snd_printk(KERN_ERR "rawmidi: cannot allocate\n"); return -ENOMEM; + } rmidi->card = card; rmidi->device = device; init_MUTEX(&rmidi->open_mutex); init_waitqueue_head(&rmidi->open_wait); if (id != NULL) strlcpy(rmidi->id, id, sizeof(rmidi->id)); - if ((err = snd_rawmidi_alloc_substreams(rmidi, &rmidi->streams[SNDRV_RAWMIDI_STREAM_INPUT], SNDRV_RAWMIDI_STREAM_INPUT, input_count)) < 0) { + if ((err = snd_rawmidi_alloc_substreams(rmidi, + &rmidi->streams[SNDRV_RAWMIDI_STREAM_INPUT], + SNDRV_RAWMIDI_STREAM_INPUT, + input_count)) < 0) { snd_rawmidi_free(rmidi); return err; } - if ((err = snd_rawmidi_alloc_substreams(rmidi, &rmidi->streams[SNDRV_RAWMIDI_STREAM_OUTPUT], SNDRV_RAWMIDI_STREAM_OUTPUT, output_count)) < 0) { + if ((err = snd_rawmidi_alloc_substreams(rmidi, + &rmidi->streams[SNDRV_RAWMIDI_STREAM_OUTPUT], + SNDRV_RAWMIDI_STREAM_OUTPUT, + output_count)) < 0) { snd_rawmidi_free(rmidi); return err; } @@ -1438,18 +1462,18 @@ int snd_rawmidi_new(snd_card_t * card, char *id, int device, return 0; } -static void snd_rawmidi_free_substreams(snd_rawmidi_str_t *stream) +static void snd_rawmidi_free_substreams(struct snd_rawmidi_str *stream) { - snd_rawmidi_substream_t *substream; + struct snd_rawmidi_substream *substream; while (!list_empty(&stream->substreams)) { - substream = list_entry(stream->substreams.next, snd_rawmidi_substream_t, list); + substream = list_entry(stream->substreams.next, struct snd_rawmidi_substream, list); list_del(&substream->list); kfree(substream); } } -static int snd_rawmidi_free(snd_rawmidi_t *rmidi) +static int snd_rawmidi_free(struct snd_rawmidi *rmidi) { snd_assert(rmidi != NULL, return -ENXIO); snd_rawmidi_free_substreams(&rmidi->streams[SNDRV_RAWMIDI_STREAM_INPUT]); @@ -1460,49 +1484,48 @@ static int snd_rawmidi_free(snd_rawmidi_t *rmidi) return 0; } -static int snd_rawmidi_dev_free(snd_device_t *device) +static int snd_rawmidi_dev_free(struct snd_device *device) { - snd_rawmidi_t *rmidi = device->device_data; + struct snd_rawmidi *rmidi = device->device_data; return snd_rawmidi_free(rmidi); } #if defined(CONFIG_SND_SEQUENCER) || (defined(MODULE) && defined(CONFIG_SND_SEQUENCER_MODULE)) -static void snd_rawmidi_dev_seq_free(snd_seq_device_t *device) +static void snd_rawmidi_dev_seq_free(struct snd_seq_device *device) { - snd_rawmidi_t *rmidi = device->private_data; + struct snd_rawmidi *rmidi = device->private_data; rmidi->seq_dev = NULL; } #endif -static int snd_rawmidi_dev_register(snd_device_t *device) +static int snd_rawmidi_dev_register(struct snd_device *device) { - int idx, err; - snd_info_entry_t *entry; + int err; + struct snd_info_entry *entry; char name[16]; - snd_rawmidi_t *rmidi = device->device_data; + struct snd_rawmidi *rmidi = device->device_data; 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_reg, 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; } @@ -1510,7 +1533,8 @@ static int snd_rawmidi_dev_register(snd_device_t *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, + rmidi, name) < 0) { snd_printk(KERN_ERR "unable to register OSS rawmidi device %i:%i\n", rmidi->card->number, 0); } else { rmidi->ossreg++; @@ -1521,7 +1545,8 @@ static int snd_rawmidi_dev_register(snd_device_t *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, + rmidi, name) < 0) { snd_printk(KERN_ERR "unable to register OSS rawmidi device %i:%i\n", rmidi->card->number, 1); } else { rmidi->ossreg++; @@ -1554,27 +1579,23 @@ static int snd_rawmidi_dev_register(snd_device_t *device) return 0; } -static int snd_rawmidi_dev_disconnect(snd_device_t *device) +static int snd_rawmidi_dev_disconnect(struct snd_device *device) { - snd_rawmidi_t *rmidi = device->device_data; - int idx; + struct snd_rawmidi *rmidi = device->device_data; 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(snd_device_t *device) +static int snd_rawmidi_dev_unregister(struct snd_device *device) { - int idx; - snd_rawmidi_t *rmidi = device->device_data; + 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; @@ -1613,13 +1634,14 @@ static int snd_rawmidi_dev_unregister(snd_device_t *device) * * Sets the rawmidi operators for the given stream direction. */ -void snd_rawmidi_set_ops(snd_rawmidi_t *rmidi, int stream, snd_rawmidi_ops_t *ops) +void snd_rawmidi_set_ops(struct snd_rawmidi *rmidi, int stream, + struct snd_rawmidi_ops *ops) { struct list_head *list; - snd_rawmidi_substream_t *substream; + struct snd_rawmidi_substream *substream; list_for_each(list, &rmidi->streams[stream].substreams) { - substream = list_entry(list, snd_rawmidi_substream_t, list); + substream = list_entry(list, struct snd_rawmidi_substream, list); substream->ops = ops; } } @@ -1672,7 +1694,6 @@ EXPORT_SYMBOL(snd_rawmidi_transmit_ack); EXPORT_SYMBOL(snd_rawmidi_transmit); EXPORT_SYMBOL(snd_rawmidi_new); EXPORT_SYMBOL(snd_rawmidi_set_ops); -EXPORT_SYMBOL(snd_rawmidi_info); EXPORT_SYMBOL(snd_rawmidi_info_select); EXPORT_SYMBOL(snd_rawmidi_kernel_open); EXPORT_SYMBOL(snd_rawmidi_kernel_release); diff --git a/sound/core/rawmidi_compat.c b/sound/core/rawmidi_compat.c index d97631c3f3a..5268c1f58c2 100644 --- a/sound/core/rawmidi_compat.c +++ b/sound/core/rawmidi_compat.c @@ -22,7 +22,7 @@ #include <linux/compat.h> -struct sndrv_rawmidi_params32 { +struct snd_rawmidi_params32 { s32 stream; u32 buffer_size; u32 avail_min; @@ -30,10 +30,10 @@ struct sndrv_rawmidi_params32 { unsigned char reserved[16]; } __attribute__((packed)); -static int snd_rawmidi_ioctl_params_compat(snd_rawmidi_file_t *rfile, - struct sndrv_rawmidi_params32 __user *src) +static int snd_rawmidi_ioctl_params_compat(struct snd_rawmidi_file *rfile, + struct snd_rawmidi_params32 __user *src) { - snd_rawmidi_params_t params; + struct snd_rawmidi_params params; unsigned int val; if (rfile->output == NULL) @@ -53,7 +53,7 @@ static int snd_rawmidi_ioctl_params_compat(snd_rawmidi_file_t *rfile, return -EINVAL; } -struct sndrv_rawmidi_status32 { +struct snd_rawmidi_status32 { s32 stream; struct compat_timespec tstamp; u32 avail; @@ -61,11 +61,11 @@ struct sndrv_rawmidi_status32 { unsigned char reserved[16]; } __attribute__((packed)); -static int snd_rawmidi_ioctl_status_compat(snd_rawmidi_file_t *rfile, - struct sndrv_rawmidi_status32 __user *src) +static int snd_rawmidi_ioctl_status_compat(struct snd_rawmidi_file *rfile, + struct snd_rawmidi_status32 __user *src) { int err; - snd_rawmidi_status_t status; + struct snd_rawmidi_status status; if (rfile->output == NULL) return -EINVAL; @@ -95,13 +95,13 @@ static int snd_rawmidi_ioctl_status_compat(snd_rawmidi_file_t *rfile, } enum { - SNDRV_RAWMIDI_IOCTL_PARAMS32 = _IOWR('W', 0x10, struct sndrv_rawmidi_params32), - SNDRV_RAWMIDI_IOCTL_STATUS32 = _IOWR('W', 0x20, struct sndrv_rawmidi_status32), + SNDRV_RAWMIDI_IOCTL_PARAMS32 = _IOWR('W', 0x10, struct snd_rawmidi_params32), + SNDRV_RAWMIDI_IOCTL_STATUS32 = _IOWR('W', 0x20, struct snd_rawmidi_status32), }; static long snd_rawmidi_ioctl_compat(struct file *file, unsigned int cmd, unsigned long arg) { - snd_rawmidi_file_t *rfile; + struct snd_rawmidi_file *rfile; void __user *argp = compat_ptr(arg); rfile = file->private_data; diff --git a/sound/core/rtctimer.c b/sound/core/rtctimer.c index c3c18568207..84704ccb182 100644 --- a/sound/core/rtctimer.c +++ b/sound/core/rtctimer.c @@ -40,16 +40,16 @@ /* * prototypes */ -static int rtctimer_open(snd_timer_t *t); -static int rtctimer_close(snd_timer_t *t); -static int rtctimer_start(snd_timer_t *t); -static int rtctimer_stop(snd_timer_t *t); +static int rtctimer_open(struct snd_timer *t); +static int rtctimer_close(struct snd_timer *t); +static int rtctimer_start(struct snd_timer *t); +static int rtctimer_stop(struct snd_timer *t); /* * The hardware dependent description for this timer. */ -static struct _snd_timer_hardware rtc_hw = { +static struct snd_timer_hardware rtc_hw = { .flags = SNDRV_TIMER_HW_FIRST|SNDRV_TIMER_HW_AUTO, .ticks = 100000000L, /* FIXME: XXX */ .open = rtctimer_open, @@ -59,12 +59,12 @@ static struct _snd_timer_hardware rtc_hw = { }; static int rtctimer_freq = RTC_FREQ; /* frequency */ -static snd_timer_t *rtctimer; +static struct snd_timer *rtctimer; static rtc_task_t rtc_task; static int -rtctimer_open(snd_timer_t *t) +rtctimer_open(struct snd_timer *t) { int err; @@ -76,7 +76,7 @@ rtctimer_open(snd_timer_t *t) } static int -rtctimer_close(snd_timer_t *t) +rtctimer_close(struct snd_timer *t) { rtc_task_t *rtc = t->private_data; if (rtc) { @@ -87,7 +87,7 @@ rtctimer_close(snd_timer_t *t) } static int -rtctimer_start(snd_timer_t *timer) +rtctimer_start(struct snd_timer *timer) { rtc_task_t *rtc = timer->private_data; snd_assert(rtc != NULL, return -EINVAL); @@ -97,7 +97,7 @@ rtctimer_start(snd_timer_t *timer) } static int -rtctimer_stop(snd_timer_t *timer) +rtctimer_stop(struct snd_timer *timer) { rtc_task_t *rtc = timer->private_data; snd_assert(rtc != NULL, return -EINVAL); @@ -120,7 +120,7 @@ static void rtctimer_interrupt(void *private_data) static int __init rtctimer_init(void) { int err; - snd_timer_t *timer; + struct snd_timer *timer; if (rtctimer_freq < 2 || rtctimer_freq > 8192 || (rtctimer_freq & (rtctimer_freq - 1)) != 0) { diff --git a/sound/core/seq/instr/ainstr_fm.c b/sound/core/seq/instr/ainstr_fm.c index 5c671e69884..b09babf272c 100644 --- a/sound/core/seq/instr/ainstr_fm.c +++ b/sound/core/seq/instr/ainstr_fm.c @@ -30,11 +30,11 @@ MODULE_AUTHOR("Uros Bizjak <uros@kss-loka.si>"); MODULE_DESCRIPTION("Advanced Linux Sound Architecture FM Instrument support."); MODULE_LICENSE("GPL"); -static int snd_seq_fm_put(void *private_data, snd_seq_kinstr_t *instr, +static int snd_seq_fm_put(void *private_data, struct snd_seq_kinstr *instr, char __user *instr_data, long len, int atomic, int cmd) { - fm_instrument_t *ip; - fm_xinstrument_t ix; + struct fm_instrument *ip; + struct fm_xinstrument ix; int idx; if (cmd != SNDRV_SEQ_INSTR_PUT_CMD_CREATE) @@ -46,7 +46,7 @@ static int snd_seq_fm_put(void *private_data, snd_seq_kinstr_t *instr, return -EFAULT; if (ix.stype != FM_STRU_INSTR) return -EINVAL; - ip = (fm_instrument_t *)KINSTR_DATA(instr); + ip = (struct fm_instrument *)KINSTR_DATA(instr); ip->share_id[0] = le32_to_cpu(ix.share_id[0]); ip->share_id[1] = le32_to_cpu(ix.share_id[1]); ip->share_id[2] = le32_to_cpu(ix.share_id[2]); @@ -72,12 +72,12 @@ static int snd_seq_fm_put(void *private_data, snd_seq_kinstr_t *instr, return 0; } -static int snd_seq_fm_get(void *private_data, snd_seq_kinstr_t *instr, +static int snd_seq_fm_get(void *private_data, struct snd_seq_kinstr *instr, char __user *instr_data, long len, int atomic, int cmd) { - fm_instrument_t *ip; - fm_xinstrument_t ix; + struct fm_instrument *ip; + struct fm_xinstrument ix; int idx; if (cmd != SNDRV_SEQ_INSTR_GET_CMD_FULL) @@ -85,7 +85,7 @@ static int snd_seq_fm_get(void *private_data, snd_seq_kinstr_t *instr, if (len < (long)sizeof(ix)) return -ENOMEM; memset(&ix, 0, sizeof(ix)); - ip = (fm_instrument_t *)KINSTR_DATA(instr); + ip = (struct fm_instrument *)KINSTR_DATA(instr); ix.stype = FM_STRU_INSTR; ix.share_id[0] = cpu_to_le32(ip->share_id[0]); ix.share_id[1] = cpu_to_le32(ip->share_id[1]); @@ -114,19 +114,19 @@ static int snd_seq_fm_get(void *private_data, snd_seq_kinstr_t *instr, return 0; } -static int snd_seq_fm_get_size(void *private_data, snd_seq_kinstr_t *instr, +static int snd_seq_fm_get_size(void *private_data, struct snd_seq_kinstr *instr, long *size) { - *size = sizeof(fm_xinstrument_t); + *size = sizeof(struct fm_xinstrument); return 0; } -int snd_seq_fm_init(snd_seq_kinstr_ops_t *ops, - snd_seq_kinstr_ops_t *next) +int snd_seq_fm_init(struct snd_seq_kinstr_ops *ops, + struct snd_seq_kinstr_ops *next) { memset(ops, 0, sizeof(*ops)); // ops->private_data = private_data; - ops->add_len = sizeof(fm_instrument_t); + ops->add_len = sizeof(struct fm_instrument); ops->instr_type = SNDRV_SEQ_INSTR_ID_OPL2_3; ops->put = snd_seq_fm_put; ops->get = snd_seq_fm_get; diff --git a/sound/core/seq/instr/ainstr_gf1.c b/sound/core/seq/instr/ainstr_gf1.c index 0e4df8826ee..3c31038a74b 100644 --- a/sound/core/seq/instr/ainstr_gf1.c +++ b/sound/core/seq/instr/ainstr_gf1.c @@ -42,14 +42,14 @@ static unsigned int snd_seq_gf1_size(unsigned int size, unsigned int format) return format; } -static int snd_seq_gf1_copy_wave_from_stream(snd_gf1_ops_t *ops, - gf1_instrument_t *ip, +static int snd_seq_gf1_copy_wave_from_stream(struct snd_gf1_ops *ops, + struct gf1_instrument *ip, char __user **data, long *len, int atomic) { - gf1_wave_t *wp, *prev; - gf1_xwave_t xp; + struct gf1_wave *wp, *prev; + struct gf1_xwave xp; int err; gfp_t gfp_mask; unsigned int real_size; @@ -116,8 +116,8 @@ static int snd_seq_gf1_copy_wave_from_stream(snd_gf1_ops_t *ops, return 0; } -static void snd_seq_gf1_wave_free(snd_gf1_ops_t *ops, - gf1_wave_t *wave, +static void snd_seq_gf1_wave_free(struct snd_gf1_ops *ops, + struct gf1_wave *wave, int atomic) { if (ops->remove_sample) @@ -125,11 +125,11 @@ static void snd_seq_gf1_wave_free(snd_gf1_ops_t *ops, kfree(wave); } -static void snd_seq_gf1_instr_free(snd_gf1_ops_t *ops, - gf1_instrument_t *ip, +static void snd_seq_gf1_instr_free(struct snd_gf1_ops *ops, + struct gf1_instrument *ip, int atomic) { - gf1_wave_t *wave; + struct gf1_wave *wave; while ((wave = ip->wave) != NULL) { ip->wave = wave->next; @@ -137,13 +137,13 @@ static void snd_seq_gf1_instr_free(snd_gf1_ops_t *ops, } } -static int snd_seq_gf1_put(void *private_data, snd_seq_kinstr_t *instr, +static int snd_seq_gf1_put(void *private_data, struct snd_seq_kinstr *instr, char __user *instr_data, long len, int atomic, int cmd) { - snd_gf1_ops_t *ops = (snd_gf1_ops_t *)private_data; - gf1_instrument_t *ip; - gf1_xinstrument_t ix; + struct snd_gf1_ops *ops = private_data; + struct gf1_instrument *ip; + struct gf1_xinstrument ix; int err; gfp_t gfp_mask; @@ -159,7 +159,7 @@ static int snd_seq_gf1_put(void *private_data, snd_seq_kinstr_t *instr, return -EINVAL; instr_data += sizeof(ix); len -= sizeof(ix); - ip = (gf1_instrument_t *)KINSTR_DATA(instr); + ip = (struct gf1_instrument *)KINSTR_DATA(instr); ip->exclusion = le16_to_cpu(ix.exclusion); ip->exclusion_group = le16_to_cpu(ix.exclusion_group); ip->effect1 = ix.effect1; @@ -189,14 +189,14 @@ static int snd_seq_gf1_put(void *private_data, snd_seq_kinstr_t *instr, return 0; } -static int snd_seq_gf1_copy_wave_to_stream(snd_gf1_ops_t *ops, - gf1_instrument_t *ip, +static int snd_seq_gf1_copy_wave_to_stream(struct snd_gf1_ops *ops, + struct gf1_instrument *ip, char __user **data, long *len, int atomic) { - gf1_wave_t *wp; - gf1_xwave_t xp; + struct gf1_wave *wp; + struct gf1_xwave xp; int err; unsigned int real_size; @@ -251,20 +251,20 @@ static int snd_seq_gf1_copy_wave_to_stream(snd_gf1_ops_t *ops, return 0; } -static int snd_seq_gf1_get(void *private_data, snd_seq_kinstr_t *instr, +static int snd_seq_gf1_get(void *private_data, struct snd_seq_kinstr *instr, char __user *instr_data, long len, int atomic, int cmd) { - snd_gf1_ops_t *ops = (snd_gf1_ops_t *)private_data; - gf1_instrument_t *ip; - gf1_xinstrument_t ix; + struct snd_gf1_ops *ops = private_data; + struct gf1_instrument *ip; + struct gf1_xinstrument ix; if (cmd != SNDRV_SEQ_INSTR_GET_CMD_FULL) return -EINVAL; if (len < (long)sizeof(ix)) return -ENOMEM; memset(&ix, 0, sizeof(ix)); - ip = (gf1_instrument_t *)KINSTR_DATA(instr); + ip = (struct gf1_instrument *)KINSTR_DATA(instr); ix.stype = GF1_STRU_INSTR; ix.exclusion = cpu_to_le16(ip->exclusion); ix.exclusion_group = cpu_to_le16(ip->exclusion_group); @@ -283,18 +283,18 @@ static int snd_seq_gf1_get(void *private_data, snd_seq_kinstr_t *instr, atomic); } -static int snd_seq_gf1_get_size(void *private_data, snd_seq_kinstr_t *instr, +static int snd_seq_gf1_get_size(void *private_data, struct snd_seq_kinstr *instr, long *size) { long result; - gf1_instrument_t *ip; - gf1_wave_t *wp; + struct gf1_instrument *ip; + struct gf1_wave *wp; *size = 0; - ip = (gf1_instrument_t *)KINSTR_DATA(instr); - result = sizeof(gf1_xinstrument_t); + ip = (struct gf1_instrument *)KINSTR_DATA(instr); + result = sizeof(struct gf1_xinstrument); for (wp = ip->wave; wp; wp = wp->next) { - result += sizeof(gf1_xwave_t); + result += sizeof(struct gf1_xwave); result += wp->size; } *size = result; @@ -302,35 +302,35 @@ static int snd_seq_gf1_get_size(void *private_data, snd_seq_kinstr_t *instr, } static int snd_seq_gf1_remove(void *private_data, - snd_seq_kinstr_t *instr, + struct snd_seq_kinstr *instr, int atomic) { - snd_gf1_ops_t *ops = (snd_gf1_ops_t *)private_data; - gf1_instrument_t *ip; + struct snd_gf1_ops *ops = private_data; + struct gf1_instrument *ip; - ip = (gf1_instrument_t *)KINSTR_DATA(instr); + ip = (struct gf1_instrument *)KINSTR_DATA(instr); snd_seq_gf1_instr_free(ops, ip, atomic); return 0; } static void snd_seq_gf1_notify(void *private_data, - snd_seq_kinstr_t *instr, + struct snd_seq_kinstr *instr, int what) { - snd_gf1_ops_t *ops = (snd_gf1_ops_t *)private_data; + struct snd_gf1_ops *ops = private_data; if (ops->notify) ops->notify(ops->private_data, instr, what); } -int snd_seq_gf1_init(snd_gf1_ops_t *ops, +int snd_seq_gf1_init(struct snd_gf1_ops *ops, void *private_data, - snd_seq_kinstr_ops_t *next) + struct snd_seq_kinstr_ops *next) { memset(ops, 0, sizeof(*ops)); ops->private_data = private_data; ops->kops.private_data = ops; - ops->kops.add_len = sizeof(gf1_instrument_t); + ops->kops.add_len = sizeof(struct gf1_instrument); ops->kops.instr_type = SNDRV_SEQ_INSTR_ID_GUS_PATCH; ops->kops.put = snd_seq_gf1_put; ops->kops.get = snd_seq_gf1_get; diff --git a/sound/core/seq/instr/ainstr_iw.c b/sound/core/seq/instr/ainstr_iw.c index 7c19fbbc5d0..7f8df19ba56 100644 --- a/sound/core/seq/instr/ainstr_iw.c +++ b/sound/core/seq/instr/ainstr_iw.c @@ -42,8 +42,8 @@ static unsigned int snd_seq_iwffff_size(unsigned int size, unsigned int format) return result; } -static void snd_seq_iwffff_copy_lfo_from_stream(iwffff_lfo_t *fp, - iwffff_xlfo_t *fx) +static void snd_seq_iwffff_copy_lfo_from_stream(struct iwffff_lfo *fp, + struct iwffff_xlfo *fx) { fp->freq = le16_to_cpu(fx->freq); fp->depth = le16_to_cpu(fx->depth); @@ -53,18 +53,18 @@ static void snd_seq_iwffff_copy_lfo_from_stream(iwffff_lfo_t *fp, } static int snd_seq_iwffff_copy_env_from_stream(__u32 req_stype, - iwffff_layer_t *lp, - iwffff_env_t *ep, - iwffff_xenv_t *ex, + struct iwffff_layer *lp, + struct iwffff_env *ep, + struct iwffff_xenv *ex, char __user **data, long *len, gfp_t gfp_mask) { __u32 stype; - iwffff_env_record_t *rp, *rp_last; - iwffff_xenv_record_t rx; - iwffff_env_point_t *pp; - iwffff_xenv_point_t px; + struct iwffff_env_record *rp, *rp_last; + struct iwffff_xenv_record rx; + struct iwffff_env_point *pp; + struct iwffff_xenv_point px; int points_size, idx; ep->flags = ex->flags; @@ -101,7 +101,7 @@ static int snd_seq_iwffff_copy_env_from_stream(__u32 req_stype, rp->sustain_rate = le16_to_cpu(rx.sustain_rate); rp->release_rate = le16_to_cpu(rx.release_rate); rp->hirange = rx.hirange; - pp = (iwffff_env_point_t *)(rp + 1); + pp = (struct iwffff_env_point *)(rp + 1); for (idx = 0; idx < rp->nattack + rp->nrelease; idx++) { if (copy_from_user(&px, *data, sizeof(px))) return -EFAULT; @@ -120,14 +120,14 @@ static int snd_seq_iwffff_copy_env_from_stream(__u32 req_stype, return 0; } -static int snd_seq_iwffff_copy_wave_from_stream(snd_iwffff_ops_t *ops, - iwffff_layer_t *lp, +static int snd_seq_iwffff_copy_wave_from_stream(struct snd_iwffff_ops *ops, + struct iwffff_layer *lp, char __user **data, long *len, int atomic) { - iwffff_wave_t *wp, *prev; - iwffff_xwave_t xp; + struct iwffff_wave *wp, *prev; + struct iwffff_xwave xp; int err; gfp_t gfp_mask; unsigned int real_size; @@ -186,11 +186,11 @@ static int snd_seq_iwffff_copy_wave_from_stream(snd_iwffff_ops_t *ops, return 0; } -static void snd_seq_iwffff_env_free(snd_iwffff_ops_t *ops, - iwffff_env_t *env, +static void snd_seq_iwffff_env_free(struct snd_iwffff_ops *ops, + struct iwffff_env *env, int atomic) { - iwffff_env_record_t *rec; + struct iwffff_env_record *rec; while ((rec = env->record) != NULL) { env->record = rec->next; @@ -198,8 +198,8 @@ static void snd_seq_iwffff_env_free(snd_iwffff_ops_t *ops, } } -static void snd_seq_iwffff_wave_free(snd_iwffff_ops_t *ops, - iwffff_wave_t *wave, +static void snd_seq_iwffff_wave_free(struct snd_iwffff_ops *ops, + struct iwffff_wave *wave, int atomic) { if (ops->remove_sample) @@ -207,12 +207,12 @@ static void snd_seq_iwffff_wave_free(snd_iwffff_ops_t *ops, kfree(wave); } -static void snd_seq_iwffff_instr_free(snd_iwffff_ops_t *ops, - iwffff_instrument_t *ip, +static void snd_seq_iwffff_instr_free(struct snd_iwffff_ops *ops, + struct iwffff_instrument *ip, int atomic) { - iwffff_layer_t *layer; - iwffff_wave_t *wave; + struct iwffff_layer *layer; + struct iwffff_wave *wave; while ((layer = ip->layer) != NULL) { ip->layer = layer->next; @@ -226,15 +226,15 @@ static void snd_seq_iwffff_instr_free(snd_iwffff_ops_t *ops, } } -static int snd_seq_iwffff_put(void *private_data, snd_seq_kinstr_t *instr, +static int snd_seq_iwffff_put(void *private_data, struct snd_seq_kinstr *instr, char __user *instr_data, long len, int atomic, int cmd) { - snd_iwffff_ops_t *ops = (snd_iwffff_ops_t *)private_data; - iwffff_instrument_t *ip; - iwffff_xinstrument_t ix; - iwffff_layer_t *lp, *prev_lp; - iwffff_xlayer_t lx; + struct snd_iwffff_ops *ops = private_data; + struct iwffff_instrument *ip; + struct iwffff_xinstrument ix; + struct iwffff_layer *lp, *prev_lp; + struct iwffff_xlayer lx; int err; gfp_t gfp_mask; @@ -250,7 +250,7 @@ static int snd_seq_iwffff_put(void *private_data, snd_seq_kinstr_t *instr, return -EINVAL; instr_data += sizeof(ix); len -= sizeof(ix); - ip = (iwffff_instrument_t *)KINSTR_DATA(instr); + ip = (struct iwffff_instrument *)KINSTR_DATA(instr); ip->exclusion = le16_to_cpu(ix.exclusion); ip->layer_type = le16_to_cpu(ix.layer_type); ip->exclusion_group = le16_to_cpu(ix.exclusion_group); @@ -261,7 +261,7 @@ static int snd_seq_iwffff_put(void *private_data, snd_seq_kinstr_t *instr, /* copy layers */ prev_lp = NULL; while (len > 0) { - if (len < (long)sizeof(iwffff_xlayer_t)) { + if (len < (long)sizeof(struct iwffff_xlayer)) { snd_seq_iwffff_instr_free(ops, ip, atomic); return -EINVAL; } @@ -335,8 +335,8 @@ static int snd_seq_iwffff_put(void *private_data, snd_seq_kinstr_t *instr, return 0; } -static void snd_seq_iwffff_copy_lfo_to_stream(iwffff_xlfo_t *fx, - iwffff_lfo_t *fp) +static void snd_seq_iwffff_copy_lfo_to_stream(struct iwffff_xlfo *fx, + struct iwffff_lfo *fp) { fx->freq = cpu_to_le16(fp->freq); fx->depth = cpu_to_le16(fp->depth); @@ -346,16 +346,16 @@ static void snd_seq_iwffff_copy_lfo_to_stream(iwffff_xlfo_t *fx, } static int snd_seq_iwffff_copy_env_to_stream(__u32 req_stype, - iwffff_layer_t *lp, - iwffff_xenv_t *ex, - iwffff_env_t *ep, + struct iwffff_layer *lp, + struct iwffff_xenv *ex, + struct iwffff_env *ep, char __user **data, long *len) { - iwffff_env_record_t *rp; - iwffff_xenv_record_t rx; - iwffff_env_point_t *pp; - iwffff_xenv_point_t px; + struct iwffff_env_record *rp; + struct iwffff_xenv_record rx; + struct iwffff_env_point *pp; + struct iwffff_xenv_point px; int points_size, idx; ex->flags = ep->flags; @@ -379,7 +379,7 @@ static int snd_seq_iwffff_copy_env_to_stream(__u32 req_stype, points_size = (rp->nattack + rp->nrelease) * 2 * sizeof(__u16); if (*len < points_size) return -ENOMEM; - pp = (iwffff_env_point_t *)(rp + 1); + pp = (struct iwffff_env_point *)(rp + 1); for (idx = 0; idx < rp->nattack + rp->nrelease; idx++) { px.offset = cpu_to_le16(pp->offset); px.rate = cpu_to_le16(pp->rate); @@ -392,14 +392,14 @@ static int snd_seq_iwffff_copy_env_to_stream(__u32 req_stype, return 0; } -static int snd_seq_iwffff_copy_wave_to_stream(snd_iwffff_ops_t *ops, - iwffff_layer_t *lp, +static int snd_seq_iwffff_copy_wave_to_stream(struct snd_iwffff_ops *ops, + struct iwffff_layer *lp, char __user **data, long *len, int atomic) { - iwffff_wave_t *wp; - iwffff_xwave_t xp; + struct iwffff_wave *wp; + struct iwffff_xwave xp; int err; unsigned int real_size; @@ -447,14 +447,14 @@ static int snd_seq_iwffff_copy_wave_to_stream(snd_iwffff_ops_t *ops, return 0; } -static int snd_seq_iwffff_get(void *private_data, snd_seq_kinstr_t *instr, +static int snd_seq_iwffff_get(void *private_data, struct snd_seq_kinstr *instr, char __user *instr_data, long len, int atomic, int cmd) { - snd_iwffff_ops_t *ops = (snd_iwffff_ops_t *)private_data; - iwffff_instrument_t *ip; - iwffff_xinstrument_t ix; - iwffff_layer_t *lp; - iwffff_xlayer_t lx; + struct snd_iwffff_ops *ops = private_data; + struct iwffff_instrument *ip; + struct iwffff_xinstrument ix; + struct iwffff_layer *lp; + struct iwffff_xlayer lx; char __user *layer_instr_data; int err; @@ -463,7 +463,7 @@ static int snd_seq_iwffff_get(void *private_data, snd_seq_kinstr_t *instr, if (len < (long)sizeof(ix)) return -ENOMEM; memset(&ix, 0, sizeof(ix)); - ip = (iwffff_instrument_t *)KINSTR_DATA(instr); + ip = (struct iwffff_instrument *)KINSTR_DATA(instr); ix.stype = IWFFFF_STRU_INSTR; ix.exclusion = cpu_to_le16(ip->exclusion); ix.layer_type = cpu_to_le16(ip->layer_type); @@ -520,43 +520,43 @@ static int snd_seq_iwffff_get(void *private_data, snd_seq_kinstr_t *instr, return 0; } -static long snd_seq_iwffff_env_size_in_stream(iwffff_env_t *ep) +static long snd_seq_iwffff_env_size_in_stream(struct iwffff_env *ep) { long result = 0; - iwffff_env_record_t *rp; + struct iwffff_env_record *rp; for (rp = ep->record; rp; rp = rp->next) { - result += sizeof(iwffff_xenv_record_t); + result += sizeof(struct iwffff_xenv_record); result += (rp->nattack + rp->nrelease) * 2 * sizeof(__u16); } return 0; } -static long snd_seq_iwffff_wave_size_in_stream(iwffff_layer_t *lp) +static long snd_seq_iwffff_wave_size_in_stream(struct iwffff_layer *lp) { long result = 0; - iwffff_wave_t *wp; + struct iwffff_wave *wp; for (wp = lp->wave; wp; wp = wp->next) { - result += sizeof(iwffff_xwave_t); + result += sizeof(struct iwffff_xwave); if (!(wp->format & IWFFFF_WAVE_ROM)) result += wp->size; } return result; } -static int snd_seq_iwffff_get_size(void *private_data, snd_seq_kinstr_t *instr, +static int snd_seq_iwffff_get_size(void *private_data, struct snd_seq_kinstr *instr, long *size) { long result; - iwffff_instrument_t *ip; - iwffff_layer_t *lp; + struct iwffff_instrument *ip; + struct iwffff_layer *lp; *size = 0; - ip = (iwffff_instrument_t *)KINSTR_DATA(instr); - result = sizeof(iwffff_xinstrument_t); + ip = (struct iwffff_instrument *)KINSTR_DATA(instr); + result = sizeof(struct iwffff_xinstrument); for (lp = ip->layer; lp; lp = lp->next) { - result += sizeof(iwffff_xlayer_t); + result += sizeof(struct iwffff_xlayer); result += snd_seq_iwffff_env_size_in_stream(&lp->penv); result += snd_seq_iwffff_env_size_in_stream(&lp->venv); result += snd_seq_iwffff_wave_size_in_stream(lp); @@ -566,35 +566,35 @@ static int snd_seq_iwffff_get_size(void *private_data, snd_seq_kinstr_t *instr, } static int snd_seq_iwffff_remove(void *private_data, - snd_seq_kinstr_t *instr, + struct snd_seq_kinstr *instr, int atomic) { - snd_iwffff_ops_t *ops = (snd_iwffff_ops_t *)private_data; - iwffff_instrument_t *ip; + struct snd_iwffff_ops *ops = private_data; + struct iwffff_instrument *ip; - ip = (iwffff_instrument_t *)KINSTR_DATA(instr); + ip = (struct iwffff_instrument *)KINSTR_DATA(instr); snd_seq_iwffff_instr_free(ops, ip, atomic); return 0; } static void snd_seq_iwffff_notify(void *private_data, - snd_seq_kinstr_t *instr, + struct snd_seq_kinstr *instr, int what) { - snd_iwffff_ops_t *ops = (snd_iwffff_ops_t *)private_data; + struct snd_iwffff_ops *ops = private_data; if (ops->notify) ops->notify(ops->private_data, instr, what); } -int snd_seq_iwffff_init(snd_iwffff_ops_t *ops, +int snd_seq_iwffff_init(struct snd_iwffff_ops *ops, void *private_data, - snd_seq_kinstr_ops_t *next) + struct snd_seq_kinstr_ops *next) { memset(ops, 0, sizeof(*ops)); ops->private_data = private_data; ops->kops.private_data = ops; - ops->kops.add_len = sizeof(iwffff_instrument_t); + ops->kops.add_len = sizeof(struct iwffff_instrument); ops->kops.instr_type = SNDRV_SEQ_INSTR_ID_INTERWAVE; ops->kops.put = snd_seq_iwffff_put; ops->kops.get = snd_seq_iwffff_get; diff --git a/sound/core/seq/instr/ainstr_simple.c b/sound/core/seq/instr/ainstr_simple.c index 17ab94e7607..6d6ffece7cb 100644 --- a/sound/core/seq/instr/ainstr_simple.c +++ b/sound/core/seq/instr/ainstr_simple.c @@ -42,21 +42,21 @@ static unsigned int snd_seq_simple_size(unsigned int size, unsigned int format) return result; } -static void snd_seq_simple_instr_free(snd_simple_ops_t *ops, - simple_instrument_t *ip, +static void snd_seq_simple_instr_free(struct snd_simple_ops *ops, + struct simple_instrument *ip, int atomic) { if (ops->remove_sample) ops->remove_sample(ops->private_data, ip, atomic); } -static int snd_seq_simple_put(void *private_data, snd_seq_kinstr_t *instr, +static int snd_seq_simple_put(void *private_data, struct snd_seq_kinstr *instr, char __user *instr_data, long len, int atomic, int cmd) { - snd_simple_ops_t *ops = (snd_simple_ops_t *)private_data; - simple_instrument_t *ip; - simple_xinstrument_t ix; + struct snd_simple_ops *ops = private_data; + struct simple_instrument *ip; + struct simple_xinstrument ix; int err; gfp_t gfp_mask; unsigned int real_size; @@ -73,7 +73,7 @@ static int snd_seq_simple_put(void *private_data, snd_seq_kinstr_t *instr, return -EINVAL; instr_data += sizeof(ix); len -= sizeof(ix); - ip = (simple_instrument_t *)KINSTR_DATA(instr); + ip = (struct simple_instrument *)KINSTR_DATA(instr); ip->share_id[0] = le32_to_cpu(ix.share_id[0]); ip->share_id[1] = le32_to_cpu(ix.share_id[1]); ip->share_id[2] = le32_to_cpu(ix.share_id[2]); @@ -100,13 +100,13 @@ static int snd_seq_simple_put(void *private_data, snd_seq_kinstr_t *instr, return 0; } -static int snd_seq_simple_get(void *private_data, snd_seq_kinstr_t *instr, +static int snd_seq_simple_get(void *private_data, struct snd_seq_kinstr *instr, char __user *instr_data, long len, int atomic, int cmd) { - snd_simple_ops_t *ops = (snd_simple_ops_t *)private_data; - simple_instrument_t *ip; - simple_xinstrument_t ix; + struct snd_simple_ops *ops = private_data; + struct simple_instrument *ip; + struct simple_xinstrument ix; int err; unsigned int real_size; @@ -115,7 +115,7 @@ static int snd_seq_simple_get(void *private_data, snd_seq_kinstr_t *instr, if (len < (long)sizeof(ix)) return -ENOMEM; memset(&ix, 0, sizeof(ix)); - ip = (simple_instrument_t *)KINSTR_DATA(instr); + ip = (struct simple_instrument *)KINSTR_DATA(instr); ix.stype = SIMPLE_STRU_INSTR; ix.share_id[0] = cpu_to_le32(ip->share_id[0]); ix.share_id[1] = cpu_to_le32(ip->share_id[1]); @@ -147,46 +147,46 @@ static int snd_seq_simple_get(void *private_data, snd_seq_kinstr_t *instr, return 0; } -static int snd_seq_simple_get_size(void *private_data, snd_seq_kinstr_t *instr, +static int snd_seq_simple_get_size(void *private_data, struct snd_seq_kinstr *instr, long *size) { - simple_instrument_t *ip; + struct simple_instrument *ip; - ip = (simple_instrument_t *)KINSTR_DATA(instr); - *size = sizeof(simple_xinstrument_t) + snd_seq_simple_size(ip->size, ip->format); + ip = (struct simple_instrument *)KINSTR_DATA(instr); + *size = sizeof(struct simple_xinstrument) + snd_seq_simple_size(ip->size, ip->format); return 0; } static int snd_seq_simple_remove(void *private_data, - snd_seq_kinstr_t *instr, + struct snd_seq_kinstr *instr, int atomic) { - snd_simple_ops_t *ops = (snd_simple_ops_t *)private_data; - simple_instrument_t *ip; + struct snd_simple_ops *ops = private_data; + struct simple_instrument *ip; - ip = (simple_instrument_t *)KINSTR_DATA(instr); + ip = (struct simple_instrument *)KINSTR_DATA(instr); snd_seq_simple_instr_free(ops, ip, atomic); return 0; } static void snd_seq_simple_notify(void *private_data, - snd_seq_kinstr_t *instr, + struct snd_seq_kinstr *instr, int what) { - snd_simple_ops_t *ops = (snd_simple_ops_t *)private_data; + struct snd_simple_ops *ops = private_data; if (ops->notify) ops->notify(ops->private_data, instr, what); } -int snd_seq_simple_init(snd_simple_ops_t *ops, +int snd_seq_simple_init(struct snd_simple_ops *ops, void *private_data, - snd_seq_kinstr_ops_t *next) + struct snd_seq_kinstr_ops *next) { memset(ops, 0, sizeof(*ops)); ops->private_data = private_data; ops->kops.private_data = ops; - ops->kops.add_len = sizeof(simple_instrument_t); + ops->kops.add_len = sizeof(struct simple_instrument); ops->kops.instr_type = SNDRV_SEQ_INSTR_ID_SIMPLE; ops->kops.put = snd_seq_simple_put; ops->kops.get = snd_seq_simple_get; diff --git a/sound/core/seq/oss/seq_oss.c b/sound/core/seq/oss/seq_oss.c index 4c0558c0a8b..c98f0ba1381 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(snd_info_entry_t *entry, snd_info_buffer_t *buf); -#endif /* @@ -73,7 +75,7 @@ static void info_read(snd_info_entry_t *entry, snd_info_buffer_t *buf); static int __init alsa_seq_oss_init(void) { int rc; - static snd_seq_dev_ops_t ops = { + static struct snd_seq_dev_ops ops = { snd_seq_oss_synth_register, snd_seq_oss_synth_unregister, }; @@ -92,7 +94,7 @@ static int __init alsa_seq_oss_init(void) } if ((rc = snd_seq_device_register_driver(SNDRV_SEQ_DEV_ID_OSS, &ops, - sizeof(snd_seq_oss_reg_t))) < 0) { + sizeof(struct snd_seq_oss_reg))) < 0) { snd_seq_oss_delete_client(); unregister_proc(); unregister_device(); @@ -144,7 +146,7 @@ odev_open(struct inode *inode, struct file *file) static int odev_release(struct inode *inode, struct file *file) { - seq_oss_devinfo_t *dp; + struct seq_oss_devinfo *dp; if ((dp = file->private_data) == NULL) return 0; @@ -161,7 +163,7 @@ odev_release(struct inode *inode, struct file *file) static ssize_t odev_read(struct file *file, char __user *buf, size_t count, loff_t *offset) { - seq_oss_devinfo_t *dp; + struct seq_oss_devinfo *dp; dp = file->private_data; snd_assert(dp != NULL, return -EIO); return snd_seq_oss_read(dp, buf, count); @@ -171,7 +173,7 @@ odev_read(struct file *file, char __user *buf, size_t count, loff_t *offset) static ssize_t odev_write(struct file *file, const char __user *buf, size_t count, loff_t *offset) { - seq_oss_devinfo_t *dp; + struct seq_oss_devinfo *dp; dp = file->private_data; snd_assert(dp != NULL, return -EIO); return snd_seq_oss_write(dp, buf, count, file); @@ -180,7 +182,7 @@ odev_write(struct file *file, const char __user *buf, size_t count, loff_t *offs static long odev_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { - seq_oss_devinfo_t *dp; + struct seq_oss_devinfo *dp; dp = file->private_data; snd_assert(dp != NULL, return -EIO); return snd_seq_oss_ioctl(dp, cmd, arg); @@ -195,7 +197,7 @@ odev_ioctl(struct file *file, unsigned int cmd, unsigned long arg) static unsigned int odev_poll(struct file *file, poll_table * wait) { - seq_oss_devinfo_t *dp; + struct seq_oss_devinfo *dp; dp = file->private_data; snd_assert(dp != NULL, return 0); return snd_seq_oss_poll(dp, file, wait); @@ -217,11 +219,6 @@ static struct file_operations seq_oss_f_ops = .compat_ioctl = odev_ioctl_compat, }; -static snd_minor_t seq_oss_reg = { - .comment = "sequencer", - .f_ops = &seq_oss_f_ops, -}; - static int __init register_device(void) { @@ -230,7 +227,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, NULL, SNDRV_SEQ_OSS_DEVNAME)) < 0) { snd_printk(KERN_ERR "can't register device seq\n"); up(®ister_mutex); @@ -238,7 +235,7 @@ register_device(void) } if ((rc = snd_register_oss_device(SNDRV_OSS_DEVICE_TYPE_MUSIC, NULL, 0, - &seq_oss_reg, + &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); @@ -268,10 +265,10 @@ unregister_device(void) #ifdef CONFIG_PROC_FS -static snd_info_entry_t *info_entry; +static struct snd_info_entry *info_entry; static void -info_read(snd_info_entry_t *entry, snd_info_buffer_t *buf) +info_read(struct snd_info_entry *entry, struct snd_info_buffer *buf) { down(®ister_mutex); snd_iprintf(buf, "OSS sequencer emulation version %s\n", SNDRV_SEQ_OSS_VERSION_STR); @@ -281,13 +278,11 @@ info_read(snd_info_entry_t *entry, snd_info_buffer_t *buf) up(®ister_mutex); } -#endif /* CONFIG_PROC_FS */ static int __init register_proc(void) { -#ifdef CONFIG_PROC_FS - snd_info_entry_t *entry; + struct snd_info_entry *entry; entry = snd_info_create_module_entry(THIS_MODULE, SNDRV_SEQ_OSS_PROCNAME, snd_seq_root); if (entry == NULL) @@ -302,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_device.h b/sound/core/seq/oss/seq_oss_device.h index 973786758c5..9a8567c928e 100644 --- a/sound/core/seq/oss/seq_oss_device.h +++ b/sound/core/seq/oss/seq_oss_device.h @@ -55,32 +55,24 @@ * type definitions */ -typedef struct seq_oss_devinfo_t seq_oss_devinfo_t; -typedef struct seq_oss_writeq_t seq_oss_writeq_t; -typedef struct seq_oss_readq_t seq_oss_readq_t; -typedef struct seq_oss_timer_t seq_oss_timer_t; -typedef struct seq_oss_synthinfo_t seq_oss_synthinfo_t; -typedef struct seq_oss_synth_sysex_t seq_oss_synth_sysex_t; -typedef struct seq_oss_chinfo_t seq_oss_chinfo_t; typedef unsigned int reltime_t; typedef unsigned int abstime_t; -typedef union evrec_t evrec_t; /* * synthesizer channel information */ -struct seq_oss_chinfo_t { +struct seq_oss_chinfo { int note, vel; }; /* * synthesizer information */ -struct seq_oss_synthinfo_t { - snd_seq_oss_arg_t arg; - seq_oss_chinfo_t *ch; - seq_oss_synth_sysex_t *sysex; +struct seq_oss_synthinfo { + struct snd_seq_oss_arg arg; + struct seq_oss_chinfo *ch; + struct seq_oss_synth_sysex *sysex; int nr_voices; int opened; int is_midi; @@ -92,14 +84,14 @@ struct seq_oss_synthinfo_t { * sequencer client information */ -struct seq_oss_devinfo_t { +struct seq_oss_devinfo { int index; /* application index */ int cseq; /* sequencer client number */ int port; /* sequencer port number */ int queue; /* sequencer queue number */ - snd_seq_addr_t addr; /* address of this device */ + struct snd_seq_addr addr; /* address of this device */ int seq_mode; /* sequencer mode */ int file_mode; /* file access */ @@ -109,17 +101,17 @@ struct seq_oss_devinfo_t { /* synth device table */ int max_synthdev; - seq_oss_synthinfo_t synths[SNDRV_SEQ_OSS_MAX_SYNTH_DEVS]; + struct seq_oss_synthinfo synths[SNDRV_SEQ_OSS_MAX_SYNTH_DEVS]; int synth_opened; /* output queue */ - seq_oss_writeq_t *writeq; + struct seq_oss_writeq *writeq; /* midi input queue */ - seq_oss_readq_t *readq; + struct seq_oss_readq *readq; /* timer */ - seq_oss_timer_t *timer; + struct seq_oss_timer *timer; }; @@ -133,24 +125,24 @@ int snd_seq_oss_delete_client(void); /* device file interface */ int snd_seq_oss_open(struct file *file, int level); -void snd_seq_oss_release(seq_oss_devinfo_t *dp); -int snd_seq_oss_ioctl(seq_oss_devinfo_t *dp, unsigned int cmd, unsigned long arg); -int snd_seq_oss_read(seq_oss_devinfo_t *dev, char __user *buf, int count); -int snd_seq_oss_write(seq_oss_devinfo_t *dp, const char __user *buf, int count, struct file *opt); -unsigned int snd_seq_oss_poll(seq_oss_devinfo_t *dp, struct file *file, poll_table * wait); +void snd_seq_oss_release(struct seq_oss_devinfo *dp); +int snd_seq_oss_ioctl(struct seq_oss_devinfo *dp, unsigned int cmd, unsigned long arg); +int snd_seq_oss_read(struct seq_oss_devinfo *dev, char __user *buf, int count); +int snd_seq_oss_write(struct seq_oss_devinfo *dp, const char __user *buf, int count, struct file *opt); +unsigned int snd_seq_oss_poll(struct seq_oss_devinfo *dp, struct file *file, poll_table * wait); -void snd_seq_oss_reset(seq_oss_devinfo_t *dp); -void snd_seq_oss_drain_write(seq_oss_devinfo_t *dp); +void snd_seq_oss_reset(struct seq_oss_devinfo *dp); +void snd_seq_oss_drain_write(struct seq_oss_devinfo *dp); /* */ -void snd_seq_oss_process_queue(seq_oss_devinfo_t *dp, abstime_t time); +void snd_seq_oss_process_queue(struct seq_oss_devinfo *dp, abstime_t time); /* proc interface */ -void snd_seq_oss_system_info_read(snd_info_buffer_t *buf); -void snd_seq_oss_midi_info_read(snd_info_buffer_t *buf); -void snd_seq_oss_synth_info_read(snd_info_buffer_t *buf); -void snd_seq_oss_readq_info_read(seq_oss_readq_t *q, snd_info_buffer_t *buf); +void snd_seq_oss_system_info_read(struct snd_info_buffer *buf); +void snd_seq_oss_midi_info_read(struct snd_info_buffer *buf); +void snd_seq_oss_synth_info_read(struct snd_info_buffer *buf); +void snd_seq_oss_readq_info_read(struct seq_oss_readq *q, struct snd_info_buffer *buf); /* file mode macros */ #define is_read_mode(mode) ((mode) & SNDRV_SEQ_OSS_FILE_READ) @@ -159,21 +151,21 @@ void snd_seq_oss_readq_info_read(seq_oss_readq_t *q, snd_info_buffer_t *buf); /* dispatch event */ static inline int -snd_seq_oss_dispatch(seq_oss_devinfo_t *dp, snd_seq_event_t *ev, int atomic, int hop) +snd_seq_oss_dispatch(struct seq_oss_devinfo *dp, struct snd_seq_event *ev, int atomic, int hop) { return snd_seq_kernel_client_dispatch(dp->cseq, ev, atomic, hop); } /* ioctl */ static inline int -snd_seq_oss_control(seq_oss_devinfo_t *dp, unsigned int type, void *arg) +snd_seq_oss_control(struct seq_oss_devinfo *dp, unsigned int type, void *arg) { return snd_seq_kernel_client_ctl(dp->cseq, type, arg); } /* fill the addresses in header */ static inline void -snd_seq_oss_fill_addr(seq_oss_devinfo_t *dp, snd_seq_event_t *ev, +snd_seq_oss_fill_addr(struct seq_oss_devinfo *dp, struct snd_seq_event *ev, int dest_client, int dest_port) { ev->queue = dp->queue; diff --git a/sound/core/seq/oss/seq_oss_event.c b/sound/core/seq/oss/seq_oss_event.c index 58e52ddd292..066f5f3e3f4 100644 --- a/sound/core/seq/oss/seq_oss_event.c +++ b/sound/core/seq/oss/seq_oss_event.c @@ -31,17 +31,17 @@ /* * prototypes */ -static int extended_event(seq_oss_devinfo_t *dp, evrec_t *q, snd_seq_event_t *ev); -static int chn_voice_event(seq_oss_devinfo_t *dp, evrec_t *event_rec, snd_seq_event_t *ev); -static int chn_common_event(seq_oss_devinfo_t *dp, evrec_t *event_rec, snd_seq_event_t *ev); -static int timing_event(seq_oss_devinfo_t *dp, evrec_t *event_rec, snd_seq_event_t *ev); -static int local_event(seq_oss_devinfo_t *dp, evrec_t *event_rec, snd_seq_event_t *ev); -static int old_event(seq_oss_devinfo_t *dp, evrec_t *q, snd_seq_event_t *ev); -static int note_on_event(seq_oss_devinfo_t *dp, int dev, int ch, int note, int vel, snd_seq_event_t *ev); -static int note_off_event(seq_oss_devinfo_t *dp, int dev, int ch, int note, int vel, snd_seq_event_t *ev); -static int set_note_event(seq_oss_devinfo_t *dp, int dev, int type, int ch, int note, int vel, snd_seq_event_t *ev); -static int set_control_event(seq_oss_devinfo_t *dp, int dev, int type, int ch, int param, int val, snd_seq_event_t *ev); -static int set_echo_event(seq_oss_devinfo_t *dp, evrec_t *rec, snd_seq_event_t *ev); +static int extended_event(struct seq_oss_devinfo *dp, union evrec *q, struct snd_seq_event *ev); +static int chn_voice_event(struct seq_oss_devinfo *dp, union evrec *event_rec, struct snd_seq_event *ev); +static int chn_common_event(struct seq_oss_devinfo *dp, union evrec *event_rec, struct snd_seq_event *ev); +static int timing_event(struct seq_oss_devinfo *dp, union evrec *event_rec, struct snd_seq_event *ev); +static int local_event(struct seq_oss_devinfo *dp, union evrec *event_rec, struct snd_seq_event *ev); +static int old_event(struct seq_oss_devinfo *dp, union evrec *q, struct snd_seq_event *ev); +static int note_on_event(struct seq_oss_devinfo *dp, int dev, int ch, int note, int vel, struct snd_seq_event *ev); +static int note_off_event(struct seq_oss_devinfo *dp, int dev, int ch, int note, int vel, struct snd_seq_event *ev); +static int set_note_event(struct seq_oss_devinfo *dp, int dev, int type, int ch, int note, int vel, struct snd_seq_event *ev); +static int set_control_event(struct seq_oss_devinfo *dp, int dev, int type, int ch, int param, int val, struct snd_seq_event *ev); +static int set_echo_event(struct seq_oss_devinfo *dp, union evrec *rec, struct snd_seq_event *ev); /* @@ -51,7 +51,7 @@ static int set_echo_event(seq_oss_devinfo_t *dp, evrec_t *rec, snd_seq_event_t * */ int -snd_seq_oss_process_event(seq_oss_devinfo_t *dp, evrec_t *q, snd_seq_event_t *ev) +snd_seq_oss_process_event(struct seq_oss_devinfo *dp, union evrec *q, struct snd_seq_event *ev) { switch (q->s.code) { case SEQ_EXTENDED: @@ -104,7 +104,7 @@ snd_seq_oss_process_event(seq_oss_devinfo_t *dp, evrec_t *q, snd_seq_event_t *ev /* old type events: mode1 only */ static int -old_event(seq_oss_devinfo_t *dp, evrec_t *q, snd_seq_event_t *ev) +old_event(struct seq_oss_devinfo *dp, union evrec *q, struct snd_seq_event *ev) { switch (q->s.code) { case SEQ_NOTEOFF: @@ -130,7 +130,7 @@ old_event(seq_oss_devinfo_t *dp, evrec_t *q, snd_seq_event_t *ev) /* 8bytes extended event: mode1 only */ static int -extended_event(seq_oss_devinfo_t *dp, evrec_t *q, snd_seq_event_t *ev) +extended_event(struct seq_oss_devinfo *dp, union evrec *q, struct snd_seq_event *ev) { int val; @@ -184,7 +184,7 @@ extended_event(seq_oss_devinfo_t *dp, evrec_t *q, snd_seq_event_t *ev) /* channel voice events: mode1 and 2 */ static int -chn_voice_event(seq_oss_devinfo_t *dp, evrec_t *q, snd_seq_event_t *ev) +chn_voice_event(struct seq_oss_devinfo *dp, union evrec *q, struct snd_seq_event *ev) { if (q->v.chn >= 32) return -EINVAL; @@ -205,7 +205,7 @@ chn_voice_event(seq_oss_devinfo_t *dp, evrec_t *q, snd_seq_event_t *ev) /* channel common events: mode1 and 2 */ static int -chn_common_event(seq_oss_devinfo_t *dp, evrec_t *q, snd_seq_event_t *ev) +chn_common_event(struct seq_oss_devinfo *dp, union evrec *q, struct snd_seq_event *ev) { if (q->l.chn >= 32) return -EINVAL; @@ -232,14 +232,14 @@ chn_common_event(seq_oss_devinfo_t *dp, evrec_t *q, snd_seq_event_t *ev) /* timer events: mode1 and mode2 */ static int -timing_event(seq_oss_devinfo_t *dp, evrec_t *q, snd_seq_event_t *ev) +timing_event(struct seq_oss_devinfo *dp, union evrec *q, struct snd_seq_event *ev) { switch (q->t.cmd) { case TMR_ECHO: if (dp->seq_mode == SNDRV_SEQ_OSS_MODE_MUSIC) return set_echo_event(dp, q, ev); else { - evrec_t tmp; + union evrec tmp; memset(&tmp, 0, sizeof(tmp)); /* XXX: only for little-endian! */ tmp.echo = (q->t.time << 8) | SEQ_ECHO; @@ -267,7 +267,7 @@ timing_event(seq_oss_devinfo_t *dp, evrec_t *q, snd_seq_event_t *ev) /* local events: mode1 and 2 */ static int -local_event(seq_oss_devinfo_t *dp, evrec_t *q, snd_seq_event_t *ev) +local_event(struct seq_oss_devinfo *dp, union evrec *q, struct snd_seq_event *ev) { return -EINVAL; } @@ -283,9 +283,9 @@ local_event(seq_oss_devinfo_t *dp, evrec_t *q, snd_seq_event_t *ev) * Use key-pressure if note >= 128 */ static int -note_on_event(seq_oss_devinfo_t *dp, int dev, int ch, int note, int vel, snd_seq_event_t *ev) +note_on_event(struct seq_oss_devinfo *dp, int dev, int ch, int note, int vel, struct snd_seq_event *ev) { - seq_oss_synthinfo_t *info = &dp->synths[dev]; + struct seq_oss_synthinfo *info = &dp->synths[dev]; switch (info->arg.event_passing) { case SNDRV_SEQ_OSS_PROCESS_EVENTS: if (! info->ch || ch < 0 || ch >= info->nr_voices) { @@ -338,9 +338,9 @@ note_on_event(seq_oss_devinfo_t *dp, int dev, int ch, int note, int vel, snd_seq * process note-off event for OSS synth */ static int -note_off_event(seq_oss_devinfo_t *dp, int dev, int ch, int note, int vel, snd_seq_event_t *ev) +note_off_event(struct seq_oss_devinfo *dp, int dev, int ch, int note, int vel, struct snd_seq_event *ev) { - seq_oss_synthinfo_t *info = &dp->synths[dev]; + struct seq_oss_synthinfo *info = &dp->synths[dev]; switch (info->arg.event_passing) { case SNDRV_SEQ_OSS_PROCESS_EVENTS: if (! info->ch || ch < 0 || ch >= info->nr_voices) { @@ -369,7 +369,7 @@ note_off_event(seq_oss_devinfo_t *dp, int dev, int ch, int note, int vel, snd_se * create a note event */ static int -set_note_event(seq_oss_devinfo_t *dp, int dev, int type, int ch, int note, int vel, snd_seq_event_t *ev) +set_note_event(struct seq_oss_devinfo *dp, int dev, int type, int ch, int note, int vel, struct snd_seq_event *ev) { if (! snd_seq_oss_synth_is_valid(dp, dev)) return -ENXIO; @@ -387,7 +387,7 @@ set_note_event(seq_oss_devinfo_t *dp, int dev, int type, int ch, int note, int v * create a control event */ static int -set_control_event(seq_oss_devinfo_t *dp, int dev, int type, int ch, int param, int val, snd_seq_event_t *ev) +set_control_event(struct seq_oss_devinfo *dp, int dev, int type, int ch, int param, int val, struct snd_seq_event *ev) { if (! snd_seq_oss_synth_is_valid(dp, dev)) return -ENXIO; @@ -405,7 +405,7 @@ set_control_event(seq_oss_devinfo_t *dp, int dev, int type, int ch, int param, i * create an echo event */ static int -set_echo_event(seq_oss_devinfo_t *dp, evrec_t *rec, snd_seq_event_t *ev) +set_echo_event(struct seq_oss_devinfo *dp, union evrec *rec, struct snd_seq_event *ev) { ev->type = SNDRV_SEQ_EVENT_ECHO; /* echo back to itself */ @@ -419,11 +419,11 @@ set_echo_event(seq_oss_devinfo_t *dp, evrec_t *rec, snd_seq_event_t *ev) * the echo event is processed here. */ int -snd_seq_oss_event_input(snd_seq_event_t *ev, int direct, void *private_data, +snd_seq_oss_event_input(struct snd_seq_event *ev, int direct, void *private_data, int atomic, int hop) { - seq_oss_devinfo_t *dp = (seq_oss_devinfo_t *)private_data; - evrec_t *rec; + struct seq_oss_devinfo *dp = (struct seq_oss_devinfo *)private_data; + union evrec *rec; if (ev->type != SNDRV_SEQ_EVENT_ECHO) return snd_seq_oss_midi_input(ev, direct, private_data); @@ -431,7 +431,7 @@ snd_seq_oss_event_input(snd_seq_event_t *ev, int direct, void *private_data, if (ev->source.client != dp->cseq) return 0; /* ignored */ - rec = (evrec_t*)&ev->data; + rec = (union evrec*)&ev->data; if (rec->s.code == SEQ_SYNCTIMER) { /* sync echo back */ snd_seq_oss_writeq_wakeup(dp->writeq, rec->t.time); diff --git a/sound/core/seq/oss/seq_oss_event.h b/sound/core/seq/oss/seq_oss_event.h index bf1d4d3f53c..9a4d9adb7b8 100644 --- a/sound/core/seq/oss/seq_oss_event.h +++ b/sound/core/seq/oss/seq_oss_event.h @@ -29,74 +29,74 @@ #define LONG_EVENT_SIZE 8 /* short event (4bytes) */ -typedef struct evrec_short_t { +struct evrec_short { unsigned char code; unsigned char parm1; unsigned char dev; unsigned char parm2; -} evrec_short_t; +}; /* short note events (4bytes) */ -typedef struct evrec_note_t { +struct evrec_note { unsigned char code; unsigned char chn; unsigned char note; unsigned char vel; -} evrec_note_t; +}; /* long timer events (8bytes) */ -typedef struct evrec_timer_t { +struct evrec_timer { unsigned char code; unsigned char cmd; unsigned char dummy1, dummy2; unsigned int time; -} evrec_timer_t; +}; /* long extended events (8bytes) */ -typedef struct evrec_extended_t { +struct evrec_extended { unsigned char code; unsigned char cmd; unsigned char dev; unsigned char chn; unsigned char p1, p2, p3, p4; -} evrec_extended_t; +}; /* long channel events (8bytes) */ -typedef struct evrec_long_t { +struct evrec_long { unsigned char code; unsigned char dev; unsigned char cmd; unsigned char chn; unsigned char p1, p2; unsigned short val; -} evrec_long_t; +}; /* channel voice events (8bytes) */ -typedef struct evrec_voice_t { +struct evrec_voice { unsigned char code; unsigned char dev; unsigned char cmd; unsigned char chn; unsigned char note, parm; unsigned short dummy; -} evrec_voice_t; +}; /* sysex events (8bytes) */ -typedef struct evrec_sysex_t { +struct evrec_sysex { unsigned char code; unsigned char dev; unsigned char buf[6]; -} evrec_sysex_t; +}; /* event record */ -union evrec_t { - evrec_short_t s; - evrec_note_t n; - evrec_long_t l; - evrec_voice_t v; - evrec_timer_t t; - evrec_extended_t e; - evrec_sysex_t x; +union evrec { + struct evrec_short s; + struct evrec_note n; + struct evrec_long l; + struct evrec_voice v; + struct evrec_timer t; + struct evrec_extended e; + struct evrec_sysex x; unsigned int echo; unsigned char c[LONG_EVENT_SIZE]; }; @@ -104,9 +104,9 @@ union evrec_t { #define ev_is_long(ev) ((ev)->s.code >= 128) #define ev_length(ev) ((ev)->s.code >= 128 ? LONG_EVENT_SIZE : SHORT_EVENT_SIZE) -int snd_seq_oss_process_event(seq_oss_devinfo_t *dp, evrec_t *q, snd_seq_event_t *ev); -int snd_seq_oss_process_timer_event(seq_oss_timer_t *rec, evrec_t *q); -int snd_seq_oss_event_input(snd_seq_event_t *ev, int direct, void *private_data, int atomic, int hop); +int snd_seq_oss_process_event(struct seq_oss_devinfo *dp, union evrec *q, struct snd_seq_event *ev); +int snd_seq_oss_process_timer_event(struct seq_oss_timer *rec, union evrec *q); +int snd_seq_oss_event_input(struct snd_seq_event *ev, int direct, void *private_data, int atomic, int hop); #endif /* __SEQ_OSS_EVENT_H */ diff --git a/sound/core/seq/oss/seq_oss_init.c b/sound/core/seq/oss/seq_oss_init.c index 1ab1cf8158c..ca5a2ed4d7c 100644 --- a/sound/core/seq/oss/seq_oss_init.c +++ b/sound/core/seq/oss/seq_oss_init.c @@ -41,17 +41,17 @@ static int system_client = -1; /* ALSA sequencer client number */ static int system_port = -1; static int num_clients; -static seq_oss_devinfo_t *client_table[SNDRV_SEQ_OSS_MAX_CLIENTS]; +static struct seq_oss_devinfo *client_table[SNDRV_SEQ_OSS_MAX_CLIENTS]; /* * prototypes */ -static int receive_announce(snd_seq_event_t *ev, int direct, void *private, int atomic, int hop); +static int receive_announce(struct snd_seq_event *ev, int direct, void *private, int atomic, int hop); static int translate_mode(struct file *file); -static int create_port(seq_oss_devinfo_t *dp); -static int delete_port(seq_oss_devinfo_t *dp); -static int alloc_seq_queue(seq_oss_devinfo_t *dp); +static int create_port(struct seq_oss_devinfo *dp); +static int delete_port(struct seq_oss_devinfo *dp); +static int alloc_seq_queue(struct seq_oss_devinfo *dp); static int delete_seq_queue(int queue); static void free_devinfo(void *private); @@ -65,40 +65,24 @@ int __init snd_seq_oss_create_client(void) { int rc; - snd_seq_client_callback_t callback; - snd_seq_client_info_t *info; - snd_seq_port_info_t *port; - snd_seq_port_callback_t port_callback; + struct snd_seq_port_info *port; + struct snd_seq_port_callback port_callback; - info = kmalloc(sizeof(*info), GFP_KERNEL); port = kmalloc(sizeof(*port), GFP_KERNEL); - if (!info || !port) { + if (!port) { rc = -ENOMEM; goto __error; } /* create ALSA client */ - memset(&callback, 0, sizeof(callback)); - - callback.private_data = NULL; - callback.allow_input = 1; - callback.allow_output = 1; - - rc = snd_seq_create_kernel_client(NULL, SNDRV_SEQ_CLIENT_OSS, &callback); + rc = snd_seq_create_kernel_client(NULL, SNDRV_SEQ_CLIENT_OSS, + "OSS sequencer"); if (rc < 0) goto __error; system_client = rc; debug_printk(("new client = %d\n", rc)); - /* set client information */ - memset(info, 0, sizeof(*info)); - info->client = system_client; - info->type = KERNEL_CLIENT; - strcpy(info->name, "OSS sequencer"); - - rc = call_ctl(SNDRV_SEQ_IOCTL_SET_CLIENT_INFO, info); - /* look up midi devices */ snd_seq_oss_midi_lookup_ports(system_client); @@ -118,7 +102,7 @@ snd_seq_oss_create_client(void) call_ctl(SNDRV_SEQ_IOCTL_CREATE_PORT, port); if ((system_port = port->addr.port) >= 0) { - snd_seq_port_subscribe_t subs; + struct snd_seq_port_subscribe subs; memset(&subs, 0, sizeof(subs)); subs.sender.client = SNDRV_SEQ_CLIENT_SYSTEM; @@ -131,7 +115,6 @@ snd_seq_oss_create_client(void) __error: kfree(port); - kfree(info); return rc; } @@ -140,9 +123,9 @@ snd_seq_oss_create_client(void) * receive annoucement from system port, and check the midi device */ static int -receive_announce(snd_seq_event_t *ev, int direct, void *private, int atomic, int hop) +receive_announce(struct snd_seq_event *ev, int direct, void *private, int atomic, int hop) { - snd_seq_port_info_t pinfo; + struct snd_seq_port_info pinfo; if (atomic) return 0; /* it must not happen */ @@ -191,7 +174,7 @@ int snd_seq_oss_open(struct file *file, int level) { int i, rc; - seq_oss_devinfo_t *dp; + struct seq_oss_devinfo *dp; if ((dp = kzalloc(sizeof(*dp), GFP_KERNEL)) == NULL) { snd_printk(KERN_ERR "can't malloc device info\n"); @@ -323,11 +306,11 @@ translate_mode(struct file *file) * create sequencer port */ static int -create_port(seq_oss_devinfo_t *dp) +create_port(struct seq_oss_devinfo *dp) { int rc; - snd_seq_port_info_t port; - snd_seq_port_callback_t callback; + struct snd_seq_port_info port; + struct snd_seq_port_callback callback; memset(&port, 0, sizeof(port)); port.addr.client = dp->cseq; @@ -358,7 +341,7 @@ create_port(seq_oss_devinfo_t *dp) * delete ALSA port */ static int -delete_port(seq_oss_devinfo_t *dp) +delete_port(struct seq_oss_devinfo *dp) { if (dp->port < 0) return 0; @@ -371,9 +354,9 @@ delete_port(seq_oss_devinfo_t *dp) * allocate a queue */ static int -alloc_seq_queue(seq_oss_devinfo_t *dp) +alloc_seq_queue(struct seq_oss_devinfo *dp) { - snd_seq_queue_info_t qinfo; + struct snd_seq_queue_info qinfo; int rc; memset(&qinfo, 0, sizeof(qinfo)); @@ -392,7 +375,7 @@ alloc_seq_queue(seq_oss_devinfo_t *dp) static int delete_seq_queue(int queue) { - snd_seq_queue_info_t qinfo; + struct snd_seq_queue_info qinfo; int rc; if (queue < 0) @@ -412,7 +395,7 @@ delete_seq_queue(int queue) static void free_devinfo(void *private) { - seq_oss_devinfo_t *dp = (seq_oss_devinfo_t *)private; + struct seq_oss_devinfo *dp = (struct seq_oss_devinfo *)private; if (dp->timer) snd_seq_oss_timer_delete(dp->timer); @@ -431,7 +414,7 @@ free_devinfo(void *private) * close sequencer device */ void -snd_seq_oss_release(seq_oss_devinfo_t *dp) +snd_seq_oss_release(struct seq_oss_devinfo *dp) { int queue; @@ -460,7 +443,7 @@ snd_seq_oss_release(seq_oss_devinfo_t *dp) * Wait until the queue is empty (if we don't have nonblock) */ void -snd_seq_oss_drain_write(seq_oss_devinfo_t *dp) +snd_seq_oss_drain_write(struct seq_oss_devinfo *dp) { if (! dp->timer->running) return; @@ -477,7 +460,7 @@ snd_seq_oss_drain_write(seq_oss_devinfo_t *dp) * reset sequencer devices */ void -snd_seq_oss_reset(seq_oss_devinfo_t *dp) +snd_seq_oss_reset(struct seq_oss_devinfo *dp) { int i; @@ -502,6 +485,7 @@ snd_seq_oss_reset(seq_oss_devinfo_t *dp) } +#ifdef CONFIG_PROC_FS /* * misc. functions for proc interface */ @@ -525,10 +509,10 @@ filemode_str(int val) * proc interface */ void -snd_seq_oss_system_info_read(snd_info_buffer_t *buf) +snd_seq_oss_system_info_read(struct snd_info_buffer *buf) { int i; - seq_oss_devinfo_t *dp; + struct seq_oss_devinfo *dp; snd_iprintf(buf, "ALSA client number %d\n", system_client); snd_iprintf(buf, "ALSA receiver port %d\n", system_port); @@ -552,4 +536,4 @@ snd_seq_oss_system_info_read(snd_info_buffer_t *buf) snd_seq_oss_readq_info_read(dp->readq, buf); } } - +#endif /* CONFIG_PROC_FS */ diff --git a/sound/core/seq/oss/seq_oss_ioctl.c b/sound/core/seq/oss/seq_oss_ioctl.c index e86f18d00f3..5ac701c903c 100644 --- a/sound/core/seq/oss/seq_oss_ioctl.c +++ b/sound/core/seq/oss/seq_oss_ioctl.c @@ -28,7 +28,7 @@ #include "seq_oss_midi.h" #include "seq_oss_event.h" -static int snd_seq_oss_synth_info_user(seq_oss_devinfo_t *dp, void __user *arg) +static int snd_seq_oss_synth_info_user(struct seq_oss_devinfo *dp, void __user *arg) { struct synth_info info; @@ -41,7 +41,7 @@ static int snd_seq_oss_synth_info_user(seq_oss_devinfo_t *dp, void __user *arg) return 0; } -static int snd_seq_oss_midi_info_user(seq_oss_devinfo_t *dp, void __user *arg) +static int snd_seq_oss_midi_info_user(struct seq_oss_devinfo *dp, void __user *arg) { struct midi_info info; @@ -54,24 +54,24 @@ static int snd_seq_oss_midi_info_user(seq_oss_devinfo_t *dp, void __user *arg) return 0; } -static int snd_seq_oss_oob_user(seq_oss_devinfo_t *dp, void __user *arg) +static int snd_seq_oss_oob_user(struct seq_oss_devinfo *dp, void __user *arg) { unsigned char ev[8]; - snd_seq_event_t tmpev; + struct snd_seq_event tmpev; if (copy_from_user(ev, arg, 8)) return -EFAULT; memset(&tmpev, 0, sizeof(tmpev)); snd_seq_oss_fill_addr(dp, &tmpev, dp->addr.port, dp->addr.client); tmpev.time.tick = 0; - if (! snd_seq_oss_process_event(dp, (evrec_t*)ev, &tmpev)) { + if (! snd_seq_oss_process_event(dp, (union evrec *)ev, &tmpev)) { snd_seq_oss_dispatch(dp, &tmpev, 0, 0); } return 0; } int -snd_seq_oss_ioctl(seq_oss_devinfo_t *dp, unsigned int cmd, unsigned long carg) +snd_seq_oss_ioctl(struct seq_oss_devinfo *dp, unsigned int cmd, unsigned long carg) { int dev, val; void __user *arg = (void __user *)carg; diff --git a/sound/core/seq/oss/seq_oss_midi.c b/sound/core/seq/oss/seq_oss_midi.c index f0e95c8f2ee..0a711d2d04f 100644 --- a/sound/core/seq/oss/seq_oss_midi.c +++ b/sound/core/seq/oss/seq_oss_midi.c @@ -37,15 +37,15 @@ /* * definition of midi device record */ -struct seq_oss_midi_t { +struct seq_oss_midi { int seq_device; /* device number */ int client; /* sequencer client number */ int port; /* sequencer port number */ unsigned int flags; /* port capability */ int opened; /* flag for opening */ unsigned char name[SNDRV_SEQ_OSS_MAX_MIDI_NAME]; - snd_midi_event_t *coder; /* MIDI event coder */ - seq_oss_devinfo_t *devinfo; /* assigned OSSseq device */ + struct snd_midi_event *coder; /* MIDI event coder */ + struct seq_oss_devinfo *devinfo; /* assigned OSSseq device */ snd_use_lock_t use_lock; }; @@ -54,17 +54,17 @@ struct seq_oss_midi_t { * midi device table */ static int max_midi_devs; -static seq_oss_midi_t *midi_devs[SNDRV_SEQ_OSS_MAX_MIDI_DEVS]; +static struct seq_oss_midi *midi_devs[SNDRV_SEQ_OSS_MAX_MIDI_DEVS]; static DEFINE_SPINLOCK(register_lock); /* * prototypes */ -static seq_oss_midi_t *get_mdev(int dev); -static seq_oss_midi_t *get_mididev(seq_oss_devinfo_t *dp, int dev); -static int send_synth_event(seq_oss_devinfo_t *dp, snd_seq_event_t *ev, int dev); -static int send_midi_event(seq_oss_devinfo_t *dp, snd_seq_event_t *ev, seq_oss_midi_t *mdev); +static struct seq_oss_midi *get_mdev(int dev); +static struct seq_oss_midi *get_mididev(struct seq_oss_devinfo *dp, int dev); +static int send_synth_event(struct seq_oss_devinfo *dp, struct snd_seq_event *ev, int dev); +static int send_midi_event(struct seq_oss_devinfo *dp, struct snd_seq_event *ev, struct seq_oss_midi *mdev); /* * look up the existing ports @@ -73,8 +73,8 @@ static int send_midi_event(seq_oss_devinfo_t *dp, snd_seq_event_t *ev, seq_oss_m int __init snd_seq_oss_midi_lookup_ports(int client) { - snd_seq_client_info_t *clinfo; - snd_seq_port_info_t *pinfo; + struct snd_seq_client_info *clinfo; + struct snd_seq_port_info *pinfo; clinfo = kzalloc(sizeof(*clinfo), GFP_KERNEL); pinfo = kzalloc(sizeof(*pinfo), GFP_KERNEL); @@ -100,10 +100,10 @@ snd_seq_oss_midi_lookup_ports(int client) /* */ -static seq_oss_midi_t * +static struct seq_oss_midi * get_mdev(int dev) { - seq_oss_midi_t *mdev; + struct seq_oss_midi *mdev; unsigned long flags; spin_lock_irqsave(®ister_lock, flags); @@ -117,11 +117,11 @@ get_mdev(int dev) /* * look for the identical slot */ -static seq_oss_midi_t * +static struct seq_oss_midi * find_slot(int client, int port) { int i; - seq_oss_midi_t *mdev; + struct seq_oss_midi *mdev; unsigned long flags; spin_lock_irqsave(®ister_lock, flags); @@ -145,10 +145,10 @@ find_slot(int client, int port) * register a new port if it doesn't exist yet */ int -snd_seq_oss_midi_check_new_port(snd_seq_port_info_t *pinfo) +snd_seq_oss_midi_check_new_port(struct snd_seq_port_info *pinfo) { int i; - seq_oss_midi_t *mdev; + struct seq_oss_midi *mdev; unsigned long flags; debug_printk(("check for MIDI client %d port %d\n", pinfo->addr.client, pinfo->addr.port)); @@ -226,7 +226,7 @@ snd_seq_oss_midi_check_new_port(snd_seq_port_info_t *pinfo) int snd_seq_oss_midi_check_exit_port(int client, int port) { - seq_oss_midi_t *mdev; + struct seq_oss_midi *mdev; unsigned long flags; int index; @@ -258,7 +258,7 @@ void snd_seq_oss_midi_clear_all(void) { int i; - seq_oss_midi_t *mdev; + struct seq_oss_midi *mdev; unsigned long flags; spin_lock_irqsave(®ister_lock, flags); @@ -279,7 +279,7 @@ snd_seq_oss_midi_clear_all(void) * set up midi tables */ void -snd_seq_oss_midi_setup(seq_oss_devinfo_t *dp) +snd_seq_oss_midi_setup(struct seq_oss_devinfo *dp) { dp->max_mididev = max_midi_devs; } @@ -288,7 +288,7 @@ snd_seq_oss_midi_setup(seq_oss_devinfo_t *dp) * clean up midi tables */ void -snd_seq_oss_midi_cleanup(seq_oss_devinfo_t *dp) +snd_seq_oss_midi_cleanup(struct seq_oss_devinfo *dp) { int i; for (i = 0; i < dp->max_mididev; i++) @@ -301,7 +301,7 @@ snd_seq_oss_midi_cleanup(seq_oss_devinfo_t *dp) * open all midi devices. ignore errors. */ void -snd_seq_oss_midi_open_all(seq_oss_devinfo_t *dp, int file_mode) +snd_seq_oss_midi_open_all(struct seq_oss_devinfo *dp, int file_mode) { int i; for (i = 0; i < dp->max_mididev; i++) @@ -312,8 +312,8 @@ snd_seq_oss_midi_open_all(seq_oss_devinfo_t *dp, int file_mode) /* * get the midi device information */ -static seq_oss_midi_t * -get_mididev(seq_oss_devinfo_t *dp, int dev) +static struct seq_oss_midi * +get_mididev(struct seq_oss_devinfo *dp, int dev) { if (dev < 0 || dev >= dp->max_mididev) return NULL; @@ -325,11 +325,11 @@ get_mididev(seq_oss_devinfo_t *dp, int dev) * open the midi device if not opened yet */ int -snd_seq_oss_midi_open(seq_oss_devinfo_t *dp, int dev, int fmode) +snd_seq_oss_midi_open(struct seq_oss_devinfo *dp, int dev, int fmode) { int perm; - seq_oss_midi_t *mdev; - snd_seq_port_subscribe_t subs; + struct seq_oss_midi *mdev; + struct snd_seq_port_subscribe subs; if ((mdev = get_mididev(dp, dev)) == NULL) return -ENODEV; @@ -392,10 +392,10 @@ snd_seq_oss_midi_open(seq_oss_devinfo_t *dp, int dev, int fmode) * close the midi device if already opened */ int -snd_seq_oss_midi_close(seq_oss_devinfo_t *dp, int dev) +snd_seq_oss_midi_close(struct seq_oss_devinfo *dp, int dev) { - seq_oss_midi_t *mdev; - snd_seq_port_subscribe_t subs; + struct seq_oss_midi *mdev; + struct snd_seq_port_subscribe subs; if ((mdev = get_mididev(dp, dev)) == NULL) return -ENODEV; @@ -430,9 +430,9 @@ snd_seq_oss_midi_close(seq_oss_devinfo_t *dp, int dev) * change seq capability flags to file mode flags */ int -snd_seq_oss_midi_filemode(seq_oss_devinfo_t *dp, int dev) +snd_seq_oss_midi_filemode(struct seq_oss_devinfo *dp, int dev) { - seq_oss_midi_t *mdev; + struct seq_oss_midi *mdev; int mode; if ((mdev = get_mididev(dp, dev)) == NULL) @@ -453,9 +453,9 @@ snd_seq_oss_midi_filemode(seq_oss_devinfo_t *dp, int dev) * so far, only close the device. */ void -snd_seq_oss_midi_reset(seq_oss_devinfo_t *dp, int dev) +snd_seq_oss_midi_reset(struct seq_oss_devinfo *dp, int dev) { - seq_oss_midi_t *mdev; + struct seq_oss_midi *mdev; if ((mdev = get_mididev(dp, dev)) == NULL) return; @@ -465,7 +465,7 @@ snd_seq_oss_midi_reset(seq_oss_devinfo_t *dp, int dev) } if (mdev->opened & PERM_WRITE) { - snd_seq_event_t ev; + struct snd_seq_event ev; int c; debug_printk(("resetting client %d port %d\n", mdev->client, mdev->port)); @@ -501,9 +501,9 @@ snd_seq_oss_midi_reset(seq_oss_devinfo_t *dp, int dev) * get client/port of the specified MIDI device */ void -snd_seq_oss_midi_get_addr(seq_oss_devinfo_t *dp, int dev, snd_seq_addr_t *addr) +snd_seq_oss_midi_get_addr(struct seq_oss_devinfo *dp, int dev, struct snd_seq_addr *addr) { - seq_oss_midi_t *mdev; + struct seq_oss_midi *mdev; if ((mdev = get_mididev(dp, dev)) == NULL) return; @@ -517,10 +517,10 @@ snd_seq_oss_midi_get_addr(seq_oss_devinfo_t *dp, int dev, snd_seq_addr_t *addr) * input callback - this can be atomic */ int -snd_seq_oss_midi_input(snd_seq_event_t *ev, int direct, void *private_data) +snd_seq_oss_midi_input(struct snd_seq_event *ev, int direct, void *private_data) { - seq_oss_devinfo_t *dp = (seq_oss_devinfo_t *)private_data; - seq_oss_midi_t *mdev; + struct seq_oss_devinfo *dp = (struct seq_oss_devinfo *)private_data; + struct seq_oss_midi *mdev; int rc; if (dp->readq == NULL) @@ -545,9 +545,9 @@ snd_seq_oss_midi_input(snd_seq_event_t *ev, int direct, void *private_data) * convert ALSA sequencer event to OSS synth event */ static int -send_synth_event(seq_oss_devinfo_t *dp, snd_seq_event_t *ev, int dev) +send_synth_event(struct seq_oss_devinfo *dp, struct snd_seq_event *ev, int dev) { - evrec_t ossev; + union evrec ossev; memset(&ossev, 0, sizeof(ossev)); @@ -606,7 +606,7 @@ send_synth_event(seq_oss_devinfo_t *dp, snd_seq_event_t *ev, int dev) * decode event and send MIDI bytes to read queue */ static int -send_midi_event(seq_oss_devinfo_t *dp, snd_seq_event_t *ev, seq_oss_midi_t *mdev) +send_midi_event(struct seq_oss_devinfo *dp, struct snd_seq_event *ev, struct seq_oss_midi *mdev) { char msg[32]; int len; @@ -634,9 +634,9 @@ send_midi_event(seq_oss_devinfo_t *dp, snd_seq_event_t *ev, seq_oss_midi_t *mdev * non-zero : invalid - ignored */ int -snd_seq_oss_midi_putc(seq_oss_devinfo_t *dp, int dev, unsigned char c, snd_seq_event_t *ev) +snd_seq_oss_midi_putc(struct seq_oss_devinfo *dp, int dev, unsigned char c, struct snd_seq_event *ev) { - seq_oss_midi_t *mdev; + struct seq_oss_midi *mdev; if ((mdev = get_mididev(dp, dev)) == NULL) return -ENODEV; @@ -653,9 +653,9 @@ snd_seq_oss_midi_putc(seq_oss_devinfo_t *dp, int dev, unsigned char c, snd_seq_e * create OSS compatible midi_info record */ int -snd_seq_oss_midi_make_info(seq_oss_devinfo_t *dp, int dev, struct midi_info *inf) +snd_seq_oss_midi_make_info(struct seq_oss_devinfo *dp, int dev, struct midi_info *inf) { - seq_oss_midi_t *mdev; + struct seq_oss_midi *mdev; if ((mdev = get_mididev(dp, dev)) == NULL) return -ENXIO; @@ -668,6 +668,7 @@ snd_seq_oss_midi_make_info(seq_oss_devinfo_t *dp, int dev, struct midi_info *inf } +#ifdef CONFIG_PROC_FS /* * proc interface */ @@ -686,10 +687,10 @@ capmode_str(int val) } void -snd_seq_oss_midi_info_read(snd_info_buffer_t *buf) +snd_seq_oss_midi_info_read(struct snd_info_buffer *buf) { int i; - seq_oss_midi_t *mdev; + struct seq_oss_midi *mdev; snd_iprintf(buf, "\nNumber of MIDI devices: %d\n", max_midi_devs); for (i = 0; i < max_midi_devs; i++) { @@ -707,4 +708,4 @@ snd_seq_oss_midi_info_read(snd_info_buffer_t *buf) snd_use_lock_free(&mdev->use_lock); } } - +#endif /* CONFIG_PROC_FS */ diff --git a/sound/core/seq/oss/seq_oss_midi.h b/sound/core/seq/oss/seq_oss_midi.h index 462484b2b6f..84eb866ba58 100644 --- a/sound/core/seq/oss/seq_oss_midi.h +++ b/sound/core/seq/oss/seq_oss_midi.h @@ -26,24 +26,23 @@ #include "seq_oss_device.h" #include <sound/seq_oss_legacy.h> -typedef struct seq_oss_midi_t seq_oss_midi_t; - int snd_seq_oss_midi_lookup_ports(int client); -int snd_seq_oss_midi_check_new_port(snd_seq_port_info_t *pinfo); +int snd_seq_oss_midi_check_new_port(struct snd_seq_port_info *pinfo); int snd_seq_oss_midi_check_exit_port(int client, int port); void snd_seq_oss_midi_clear_all(void); -void snd_seq_oss_midi_setup(seq_oss_devinfo_t *dp); -void snd_seq_oss_midi_cleanup(seq_oss_devinfo_t *dp); +void snd_seq_oss_midi_setup(struct seq_oss_devinfo *dp); +void snd_seq_oss_midi_cleanup(struct seq_oss_devinfo *dp); -int snd_seq_oss_midi_open(seq_oss_devinfo_t *dp, int dev, int file_mode); -void snd_seq_oss_midi_open_all(seq_oss_devinfo_t *dp, int file_mode); -int snd_seq_oss_midi_close(seq_oss_devinfo_t *dp, int dev); -void snd_seq_oss_midi_reset(seq_oss_devinfo_t *dp, int dev); -int snd_seq_oss_midi_putc(seq_oss_devinfo_t *dp, int dev, unsigned char c, snd_seq_event_t *ev); -int snd_seq_oss_midi_input(snd_seq_event_t *ev, int direct, void *private); -int snd_seq_oss_midi_filemode(seq_oss_devinfo_t *dp, int dev); -int snd_seq_oss_midi_make_info(seq_oss_devinfo_t *dp, int dev, struct midi_info *inf); -void snd_seq_oss_midi_get_addr(seq_oss_devinfo_t *dp, int dev, snd_seq_addr_t *addr); +int snd_seq_oss_midi_open(struct seq_oss_devinfo *dp, int dev, int file_mode); +void snd_seq_oss_midi_open_all(struct seq_oss_devinfo *dp, int file_mode); +int snd_seq_oss_midi_close(struct seq_oss_devinfo *dp, int dev); +void snd_seq_oss_midi_reset(struct seq_oss_devinfo *dp, int dev); +int snd_seq_oss_midi_putc(struct seq_oss_devinfo *dp, int dev, unsigned char c, + struct snd_seq_event *ev); +int snd_seq_oss_midi_input(struct snd_seq_event *ev, int direct, void *private); +int snd_seq_oss_midi_filemode(struct seq_oss_devinfo *dp, int dev); +int snd_seq_oss_midi_make_info(struct seq_oss_devinfo *dp, int dev, struct midi_info *inf); +void snd_seq_oss_midi_get_addr(struct seq_oss_devinfo *dp, int dev, struct snd_seq_addr *addr); #endif diff --git a/sound/core/seq/oss/seq_oss_readq.c b/sound/core/seq/oss/seq_oss_readq.c index 55571e15cd3..f5de79f29f1 100644 --- a/sound/core/seq/oss/seq_oss_readq.c +++ b/sound/core/seq/oss/seq_oss_readq.c @@ -41,17 +41,17 @@ /* * create a read queue */ -seq_oss_readq_t * -snd_seq_oss_readq_new(seq_oss_devinfo_t *dp, int maxlen) +struct seq_oss_readq * +snd_seq_oss_readq_new(struct seq_oss_devinfo *dp, int maxlen) { - seq_oss_readq_t *q; + struct seq_oss_readq *q; if ((q = kzalloc(sizeof(*q), GFP_KERNEL)) == NULL) { snd_printk(KERN_ERR "can't malloc read queue\n"); return NULL; } - if ((q->q = kcalloc(maxlen, sizeof(evrec_t), GFP_KERNEL)) == NULL) { + if ((q->q = kcalloc(maxlen, sizeof(union evrec), GFP_KERNEL)) == NULL) { snd_printk(KERN_ERR "can't malloc read queue buffer\n"); kfree(q); return NULL; @@ -72,7 +72,7 @@ snd_seq_oss_readq_new(seq_oss_devinfo_t *dp, int maxlen) * delete the read queue */ void -snd_seq_oss_readq_delete(seq_oss_readq_t *q) +snd_seq_oss_readq_delete(struct seq_oss_readq *q) { if (q) { kfree(q->q); @@ -84,7 +84,7 @@ snd_seq_oss_readq_delete(seq_oss_readq_t *q) * reset the read queue */ void -snd_seq_oss_readq_clear(seq_oss_readq_t *q) +snd_seq_oss_readq_clear(struct seq_oss_readq *q) { if (q->qlen) { q->qlen = 0; @@ -100,9 +100,9 @@ snd_seq_oss_readq_clear(seq_oss_readq_t *q) * put a midi byte */ int -snd_seq_oss_readq_puts(seq_oss_readq_t *q, int dev, unsigned char *data, int len) +snd_seq_oss_readq_puts(struct seq_oss_readq *q, int dev, unsigned char *data, int len) { - evrec_t rec; + union evrec rec; int result; memset(&rec, 0, sizeof(rec)); @@ -123,7 +123,7 @@ snd_seq_oss_readq_puts(seq_oss_readq_t *q, int dev, unsigned char *data, int len * return zero if enqueued */ int -snd_seq_oss_readq_put_event(seq_oss_readq_t *q, evrec_t *ev) +snd_seq_oss_readq_put_event(struct seq_oss_readq *q, union evrec *ev) { unsigned long flags; @@ -152,7 +152,7 @@ snd_seq_oss_readq_put_event(seq_oss_readq_t *q, evrec_t *ev) * caller must hold lock */ int -snd_seq_oss_readq_pick(seq_oss_readq_t *q, evrec_t *rec) +snd_seq_oss_readq_pick(struct seq_oss_readq *q, union evrec *rec) { if (q->qlen == 0) return -EAGAIN; @@ -164,7 +164,7 @@ snd_seq_oss_readq_pick(seq_oss_readq_t *q, evrec_t *rec) * sleep until ready */ void -snd_seq_oss_readq_wait(seq_oss_readq_t *q) +snd_seq_oss_readq_wait(struct seq_oss_readq *q) { wait_event_interruptible_timeout(q->midi_sleep, (q->qlen > 0 || q->head == q->tail), @@ -176,7 +176,7 @@ snd_seq_oss_readq_wait(seq_oss_readq_t *q) * caller must hold lock */ void -snd_seq_oss_readq_free(seq_oss_readq_t *q) +snd_seq_oss_readq_free(struct seq_oss_readq *q) { if (q->qlen > 0) { q->head = (q->head + 1) % q->maxlen; @@ -189,7 +189,7 @@ snd_seq_oss_readq_free(seq_oss_readq_t *q) * return non-zero if readq is not empty. */ unsigned int -snd_seq_oss_readq_poll(seq_oss_readq_t *q, struct file *file, poll_table *wait) +snd_seq_oss_readq_poll(struct seq_oss_readq *q, struct file *file, poll_table *wait) { poll_wait(file, &q->midi_sleep, wait); return q->qlen; @@ -199,10 +199,10 @@ snd_seq_oss_readq_poll(seq_oss_readq_t *q, struct file *file, poll_table *wait) * put a timestamp */ int -snd_seq_oss_readq_put_timestamp(seq_oss_readq_t *q, unsigned long curt, int seq_mode) +snd_seq_oss_readq_put_timestamp(struct seq_oss_readq *q, unsigned long curt, int seq_mode) { if (curt != q->input_time) { - evrec_t rec; + union evrec rec; memset(&rec, 0, sizeof(rec)); switch (seq_mode) { case SNDRV_SEQ_OSS_MODE_SYNTH: @@ -222,13 +222,15 @@ snd_seq_oss_readq_put_timestamp(seq_oss_readq_t *q, unsigned long curt, int seq_ } +#ifdef CONFIG_PROC_FS /* * proc interface */ void -snd_seq_oss_readq_info_read(seq_oss_readq_t *q, snd_info_buffer_t *buf) +snd_seq_oss_readq_info_read(struct seq_oss_readq *q, struct snd_info_buffer *buf) { snd_iprintf(buf, " read queue [%s] length = %d : tick = %ld\n", (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_readq.h b/sound/core/seq/oss/seq_oss_readq.h index 303b9298f20..f1463f1f449 100644 --- a/sound/core/seq/oss/seq_oss_readq.h +++ b/sound/core/seq/oss/seq_oss_readq.h @@ -28,8 +28,8 @@ /* * definition of read queue */ -struct seq_oss_readq_t { - evrec_t *q; +struct seq_oss_readq { + union evrec *q; int qlen; int maxlen; int head, tail; @@ -39,16 +39,16 @@ struct seq_oss_readq_t { spinlock_t lock; }; -seq_oss_readq_t *snd_seq_oss_readq_new(seq_oss_devinfo_t *dp, int maxlen); -void snd_seq_oss_readq_delete(seq_oss_readq_t *q); -void snd_seq_oss_readq_clear(seq_oss_readq_t *readq); -unsigned int snd_seq_oss_readq_poll(seq_oss_readq_t *readq, struct file *file, poll_table *wait); -int snd_seq_oss_readq_puts(seq_oss_readq_t *readq, int dev, unsigned char *data, int len); -int snd_seq_oss_readq_put_event(seq_oss_readq_t *readq, evrec_t *ev); -int snd_seq_oss_readq_put_timestamp(seq_oss_readq_t *readq, unsigned long curt, int seq_mode); -int snd_seq_oss_readq_pick(seq_oss_readq_t *q, evrec_t *rec); -void snd_seq_oss_readq_wait(seq_oss_readq_t *q); -void snd_seq_oss_readq_free(seq_oss_readq_t *q); +struct seq_oss_readq *snd_seq_oss_readq_new(struct seq_oss_devinfo *dp, int maxlen); +void snd_seq_oss_readq_delete(struct seq_oss_readq *q); +void snd_seq_oss_readq_clear(struct seq_oss_readq *readq); +unsigned int snd_seq_oss_readq_poll(struct seq_oss_readq *readq, struct file *file, poll_table *wait); +int snd_seq_oss_readq_puts(struct seq_oss_readq *readq, int dev, unsigned char *data, int len); +int snd_seq_oss_readq_put_event(struct seq_oss_readq *readq, union evrec *ev); +int snd_seq_oss_readq_put_timestamp(struct seq_oss_readq *readq, unsigned long curt, int seq_mode); +int snd_seq_oss_readq_pick(struct seq_oss_readq *q, union evrec *rec); +void snd_seq_oss_readq_wait(struct seq_oss_readq *q); +void snd_seq_oss_readq_free(struct seq_oss_readq *q); #define snd_seq_oss_readq_lock(q, flags) spin_lock_irqsave(&(q)->lock, flags) #define snd_seq_oss_readq_unlock(q, flags) spin_unlock_irqrestore(&(q)->lock, flags) diff --git a/sound/core/seq/oss/seq_oss_rw.c b/sound/core/seq/oss/seq_oss_rw.c index 1d8fbd22e3e..6a7b6aceeca 100644 --- a/sound/core/seq/oss/seq_oss_rw.c +++ b/sound/core/seq/oss/seq_oss_rw.c @@ -33,7 +33,7 @@ /* * protoypes */ -static int insert_queue(seq_oss_devinfo_t *dp, evrec_t *rec, struct file *opt); +static int insert_queue(struct seq_oss_devinfo *dp, union evrec *rec, struct file *opt); /* @@ -41,12 +41,12 @@ static int insert_queue(seq_oss_devinfo_t *dp, evrec_t *rec, struct file *opt); */ int -snd_seq_oss_read(seq_oss_devinfo_t *dp, char __user *buf, int count) +snd_seq_oss_read(struct seq_oss_devinfo *dp, char __user *buf, int count) { - seq_oss_readq_t *readq = dp->readq; + struct seq_oss_readq *readq = dp->readq; int result = 0, err = 0; int ev_len; - evrec_t rec; + union evrec rec; unsigned long flags; if (readq == NULL || ! is_read_mode(dp->file_mode)) @@ -93,11 +93,11 @@ snd_seq_oss_read(seq_oss_devinfo_t *dp, char __user *buf, int count) */ int -snd_seq_oss_write(seq_oss_devinfo_t *dp, const char __user *buf, int count, struct file *opt) +snd_seq_oss_write(struct seq_oss_devinfo *dp, const char __user *buf, int count, struct file *opt) { int result = 0, err = 0; int ev_size, fmt; - evrec_t rec; + union evrec rec; if (! is_write_mode(dp->file_mode) || dp->writeq == NULL) return -ENXIO; @@ -161,10 +161,10 @@ snd_seq_oss_write(seq_oss_devinfo_t *dp, const char __user *buf, int count, stru * return: 0 = OK, non-zero = NG */ static int -insert_queue(seq_oss_devinfo_t *dp, evrec_t *rec, struct file *opt) +insert_queue(struct seq_oss_devinfo *dp, union evrec *rec, struct file *opt) { int rc = 0; - snd_seq_event_t event; + struct snd_seq_event event; /* if this is a timing event, process the current time */ if (snd_seq_oss_process_timer_event(dp->timer, rec)) @@ -197,7 +197,7 @@ insert_queue(seq_oss_devinfo_t *dp, evrec_t *rec, struct file *opt) */ unsigned int -snd_seq_oss_poll(seq_oss_devinfo_t *dp, struct file *file, poll_table * wait) +snd_seq_oss_poll(struct seq_oss_devinfo *dp, struct file *file, poll_table * wait) { unsigned int mask = 0; diff --git a/sound/core/seq/oss/seq_oss_synth.c b/sound/core/seq/oss/seq_oss_synth.c index 8257fce2ca1..ab570a0a618 100644 --- a/sound/core/seq/oss/seq_oss_synth.c +++ b/sound/core/seq/oss/seq_oss_synth.c @@ -37,14 +37,14 @@ */ /* sysex buffer */ -struct seq_oss_synth_sysex_t { +struct seq_oss_synth_sysex { int len; int skip; unsigned char buf[MAX_SYSEX_BUFLEN]; }; /* synth info */ -struct seq_oss_synth_t { +struct seq_oss_synth { int seq_device; /* for synth_info */ @@ -53,7 +53,7 @@ struct seq_oss_synth_t { int nr_voices; char name[SNDRV_SEQ_OSS_MAX_SYNTH_NAME]; - snd_seq_oss_callback_t oper; + struct snd_seq_oss_callback oper; int opened; @@ -66,8 +66,8 @@ struct seq_oss_synth_t { * device table */ static int max_synth_devs; -static seq_oss_synth_t *synth_devs[SNDRV_SEQ_OSS_MAX_SYNTH_DEVS]; -static seq_oss_synth_t midi_synth_dev = { +static struct seq_oss_synth *synth_devs[SNDRV_SEQ_OSS_MAX_SYNTH_DEVS]; +static struct seq_oss_synth midi_synth_dev = { -1, /* seq_device */ SYNTH_TYPE_MIDI, /* synth_type */ 0, /* synth_subtype */ @@ -80,8 +80,8 @@ static DEFINE_SPINLOCK(register_lock); /* * prototypes */ -static seq_oss_synth_t *get_synthdev(seq_oss_devinfo_t *dp, int dev); -static void reset_channels(seq_oss_synthinfo_t *info); +static struct seq_oss_synth *get_synthdev(struct seq_oss_devinfo *dp, int dev); +static void reset_channels(struct seq_oss_synthinfo *info); /* * global initialization @@ -96,11 +96,11 @@ snd_seq_oss_synth_init(void) * registration of the synth device */ int -snd_seq_oss_synth_register(snd_seq_device_t *dev) +snd_seq_oss_synth_register(struct snd_seq_device *dev) { int i; - seq_oss_synth_t *rec; - snd_seq_oss_reg_t *reg = SNDRV_SEQ_DEVICE_ARGPTR(dev); + struct seq_oss_synth *rec; + struct snd_seq_oss_reg *reg = SNDRV_SEQ_DEVICE_ARGPTR(dev); unsigned long flags; if ((rec = kzalloc(sizeof(*rec), GFP_KERNEL)) == NULL) { @@ -148,10 +148,10 @@ snd_seq_oss_synth_register(snd_seq_device_t *dev) int -snd_seq_oss_synth_unregister(snd_seq_device_t *dev) +snd_seq_oss_synth_unregister(struct snd_seq_device *dev) { int index; - seq_oss_synth_t *rec = dev->driver_data; + struct seq_oss_synth *rec = dev->driver_data; unsigned long flags; spin_lock_irqsave(®ister_lock, flags); @@ -187,10 +187,10 @@ snd_seq_oss_synth_unregister(snd_seq_device_t *dev) /* */ -static seq_oss_synth_t * +static struct seq_oss_synth * get_sdev(int dev) { - seq_oss_synth_t *rec; + struct seq_oss_synth *rec; unsigned long flags; spin_lock_irqsave(®ister_lock, flags); @@ -207,11 +207,11 @@ get_sdev(int dev) */ void -snd_seq_oss_synth_setup(seq_oss_devinfo_t *dp) +snd_seq_oss_synth_setup(struct seq_oss_devinfo *dp) { int i; - seq_oss_synth_t *rec; - seq_oss_synthinfo_t *info; + struct seq_oss_synth *rec; + struct seq_oss_synthinfo *info; dp->max_synthdev = max_synth_devs; dp->synth_opened = 0; @@ -244,7 +244,7 @@ snd_seq_oss_synth_setup(seq_oss_devinfo_t *dp) } info->nr_voices = rec->nr_voices; if (info->nr_voices > 0) { - info->ch = kcalloc(info->nr_voices, sizeof(seq_oss_chinfo_t), GFP_KERNEL); + info->ch = kcalloc(info->nr_voices, sizeof(struct seq_oss_chinfo), GFP_KERNEL); if (!info->ch) BUG(); reset_channels(info); @@ -263,7 +263,7 @@ snd_seq_oss_synth_setup(seq_oss_devinfo_t *dp) */ void -snd_seq_oss_synth_setup_midi(seq_oss_devinfo_t *dp) +snd_seq_oss_synth_setup_midi(struct seq_oss_devinfo *dp) { int i; @@ -271,7 +271,7 @@ snd_seq_oss_synth_setup_midi(seq_oss_devinfo_t *dp) return; for (i = 0; i < dp->max_mididev; i++) { - seq_oss_synthinfo_t *info; + struct seq_oss_synthinfo *info; info = &dp->synths[dp->max_synthdev]; if (snd_seq_oss_midi_open(dp, i, dp->file_mode) < 0) continue; @@ -297,11 +297,11 @@ snd_seq_oss_synth_setup_midi(seq_oss_devinfo_t *dp) */ void -snd_seq_oss_synth_cleanup(seq_oss_devinfo_t *dp) +snd_seq_oss_synth_cleanup(struct seq_oss_devinfo *dp) { int i; - seq_oss_synth_t *rec; - seq_oss_synthinfo_t *info; + struct seq_oss_synth *rec; + struct seq_oss_synthinfo *info; snd_assert(dp->max_synthdev <= SNDRV_SEQ_OSS_MAX_SYNTH_DEVS, return); for (i = 0; i < dp->max_synthdev; i++) { @@ -338,7 +338,7 @@ snd_seq_oss_synth_cleanup(seq_oss_devinfo_t *dp) * check if the specified device is MIDI mapped device */ static int -is_midi_dev(seq_oss_devinfo_t *dp, int dev) +is_midi_dev(struct seq_oss_devinfo *dp, int dev) { if (dev < 0 || dev >= dp->max_synthdev) return 0; @@ -350,10 +350,10 @@ is_midi_dev(seq_oss_devinfo_t *dp, int dev) /* * return synth device information pointer */ -static seq_oss_synth_t * -get_synthdev(seq_oss_devinfo_t *dp, int dev) +static struct seq_oss_synth * +get_synthdev(struct seq_oss_devinfo *dp, int dev) { - seq_oss_synth_t *rec; + struct seq_oss_synth *rec; if (dev < 0 || dev >= dp->max_synthdev) return NULL; if (! dp->synths[dev].opened) @@ -374,7 +374,7 @@ get_synthdev(seq_oss_devinfo_t *dp, int dev) * reset note and velocity on each channel. */ static void -reset_channels(seq_oss_synthinfo_t *info) +reset_channels(struct seq_oss_synthinfo *info) { int i; if (info->ch == NULL || ! info->nr_voices) @@ -392,10 +392,10 @@ reset_channels(seq_oss_synthinfo_t *info) * event to the corresponding port. */ void -snd_seq_oss_synth_reset(seq_oss_devinfo_t *dp, int dev) +snd_seq_oss_synth_reset(struct seq_oss_devinfo *dp, int dev) { - seq_oss_synth_t *rec; - seq_oss_synthinfo_t *info; + struct seq_oss_synth *rec; + struct seq_oss_synthinfo *info; snd_assert(dev >= 0 && dev < dp->max_synthdev, return); info = &dp->synths[dev]; @@ -428,7 +428,7 @@ snd_seq_oss_synth_reset(seq_oss_devinfo_t *dp, int dev) if (rec->oper.reset) { rec->oper.reset(&info->arg); } else { - snd_seq_event_t ev; + struct snd_seq_event ev; memset(&ev, 0, sizeof(ev)); snd_seq_oss_fill_addr(dp, &ev, info->arg.addr.client, info->arg.addr.port); @@ -444,10 +444,10 @@ snd_seq_oss_synth_reset(seq_oss_devinfo_t *dp, int dev) * call load_patch callback function */ int -snd_seq_oss_synth_load_patch(seq_oss_devinfo_t *dp, int dev, int fmt, +snd_seq_oss_synth_load_patch(struct seq_oss_devinfo *dp, int dev, int fmt, const char __user *buf, int p, int c) { - seq_oss_synth_t *rec; + struct seq_oss_synth *rec; int rc; if (dev < 0 || dev >= dp->max_synthdev) @@ -470,9 +470,9 @@ snd_seq_oss_synth_load_patch(seq_oss_devinfo_t *dp, int dev, int fmt, * check if the device is valid synth device */ int -snd_seq_oss_synth_is_valid(seq_oss_devinfo_t *dp, int dev) +snd_seq_oss_synth_is_valid(struct seq_oss_devinfo *dp, int dev) { - seq_oss_synth_t *rec; + struct seq_oss_synth *rec; rec = get_synthdev(dp, dev); if (rec) { snd_use_lock_free(&rec->use_lock); @@ -488,11 +488,11 @@ snd_seq_oss_synth_is_valid(seq_oss_devinfo_t *dp, int dev) * (0xff). */ int -snd_seq_oss_synth_sysex(seq_oss_devinfo_t *dp, int dev, unsigned char *buf, snd_seq_event_t *ev) +snd_seq_oss_synth_sysex(struct seq_oss_devinfo *dp, int dev, unsigned char *buf, struct snd_seq_event *ev) { int i, send; unsigned char *dest; - seq_oss_synth_sysex_t *sysex; + struct seq_oss_synth_sysex *sysex; if (! snd_seq_oss_synth_is_valid(dp, dev)) return -ENXIO; @@ -545,7 +545,7 @@ snd_seq_oss_synth_sysex(seq_oss_devinfo_t *dp, int dev, unsigned char *buf, snd_ * fill the event source/destination addresses */ int -snd_seq_oss_synth_addr(seq_oss_devinfo_t *dp, int dev, snd_seq_event_t *ev) +snd_seq_oss_synth_addr(struct seq_oss_devinfo *dp, int dev, struct snd_seq_event *ev) { if (! snd_seq_oss_synth_is_valid(dp, dev)) return -EINVAL; @@ -559,9 +559,9 @@ snd_seq_oss_synth_addr(seq_oss_devinfo_t *dp, int dev, snd_seq_event_t *ev) * OSS compatible ioctl */ int -snd_seq_oss_synth_ioctl(seq_oss_devinfo_t *dp, int dev, unsigned int cmd, unsigned long addr) +snd_seq_oss_synth_ioctl(struct seq_oss_devinfo *dp, int dev, unsigned int cmd, unsigned long addr) { - seq_oss_synth_t *rec; + struct seq_oss_synth *rec; int rc; if (is_midi_dev(dp, dev)) @@ -581,7 +581,7 @@ snd_seq_oss_synth_ioctl(seq_oss_devinfo_t *dp, int dev, unsigned int cmd, unsign * send OSS raw events - SEQ_PRIVATE and SEQ_VOLUME */ int -snd_seq_oss_synth_raw_event(seq_oss_devinfo_t *dp, int dev, unsigned char *data, snd_seq_event_t *ev) +snd_seq_oss_synth_raw_event(struct seq_oss_devinfo *dp, int dev, unsigned char *data, struct snd_seq_event *ev) { if (! snd_seq_oss_synth_is_valid(dp, dev) || is_midi_dev(dp, dev)) return -ENXIO; @@ -595,9 +595,9 @@ snd_seq_oss_synth_raw_event(seq_oss_devinfo_t *dp, int dev, unsigned char *data, * create OSS compatible synth_info record */ int -snd_seq_oss_synth_make_info(seq_oss_devinfo_t *dp, int dev, struct synth_info *inf) +snd_seq_oss_synth_make_info(struct seq_oss_devinfo *dp, int dev, struct synth_info *inf) { - seq_oss_synth_t *rec; + struct seq_oss_synth *rec; if (dp->synths[dev].is_midi) { struct midi_info minf; @@ -621,14 +621,15 @@ snd_seq_oss_synth_make_info(seq_oss_devinfo_t *dp, int dev, struct synth_info *i } +#ifdef CONFIG_PROC_FS /* * proc interface */ void -snd_seq_oss_synth_info_read(snd_info_buffer_t *buf) +snd_seq_oss_synth_info_read(struct snd_info_buffer *buf) { int i; - seq_oss_synth_t *rec; + struct seq_oss_synth *rec; snd_iprintf(buf, "\nNumber of synth devices: %d\n", max_synth_devs); for (i = 0; i < max_synth_devs; i++) { @@ -648,4 +649,4 @@ snd_seq_oss_synth_info_read(snd_info_buffer_t *buf) snd_use_lock_free(&rec->use_lock); } } - +#endif /* CONFIG_PROC_FS */ diff --git a/sound/core/seq/oss/seq_oss_synth.h b/sound/core/seq/oss/seq_oss_synth.h index 07bc0e2cfb8..dbdfcbb80ea 100644 --- a/sound/core/seq/oss/seq_oss_synth.h +++ b/sound/core/seq/oss/seq_oss_synth.h @@ -27,23 +27,25 @@ #include <sound/seq_oss_legacy.h> #include <sound/seq_device.h> -typedef struct seq_oss_synth_t seq_oss_synth_t; - void snd_seq_oss_synth_init(void); -int snd_seq_oss_synth_register(snd_seq_device_t *dev); -int snd_seq_oss_synth_unregister(snd_seq_device_t *dev); -void snd_seq_oss_synth_setup(seq_oss_devinfo_t *dp); -void snd_seq_oss_synth_setup_midi(seq_oss_devinfo_t *dp); -void snd_seq_oss_synth_cleanup(seq_oss_devinfo_t *dp); +int snd_seq_oss_synth_register(struct snd_seq_device *dev); +int snd_seq_oss_synth_unregister(struct snd_seq_device *dev); +void snd_seq_oss_synth_setup(struct seq_oss_devinfo *dp); +void snd_seq_oss_synth_setup_midi(struct seq_oss_devinfo *dp); +void snd_seq_oss_synth_cleanup(struct seq_oss_devinfo *dp); -void snd_seq_oss_synth_reset(seq_oss_devinfo_t *dp, int dev); -int snd_seq_oss_synth_load_patch(seq_oss_devinfo_t *dp, int dev, int fmt, const char __user *buf, int p, int c); -int snd_seq_oss_synth_is_valid(seq_oss_devinfo_t *dp, int dev); -int snd_seq_oss_synth_sysex(seq_oss_devinfo_t *dp, int dev, unsigned char *buf, snd_seq_event_t *ev); -int snd_seq_oss_synth_addr(seq_oss_devinfo_t *dp, int dev, snd_seq_event_t *ev); -int snd_seq_oss_synth_ioctl(seq_oss_devinfo_t *dp, int dev, unsigned int cmd, unsigned long addr); -int snd_seq_oss_synth_raw_event(seq_oss_devinfo_t *dp, int dev, unsigned char *data, snd_seq_event_t *ev); +void snd_seq_oss_synth_reset(struct seq_oss_devinfo *dp, int dev); +int snd_seq_oss_synth_load_patch(struct seq_oss_devinfo *dp, int dev, int fmt, + const char __user *buf, int p, int c); +int snd_seq_oss_synth_is_valid(struct seq_oss_devinfo *dp, int dev); +int snd_seq_oss_synth_sysex(struct seq_oss_devinfo *dp, int dev, unsigned char *buf, + struct snd_seq_event *ev); +int snd_seq_oss_synth_addr(struct seq_oss_devinfo *dp, int dev, struct snd_seq_event *ev); +int snd_seq_oss_synth_ioctl(struct seq_oss_devinfo *dp, int dev, unsigned int cmd, + unsigned long addr); +int snd_seq_oss_synth_raw_event(struct seq_oss_devinfo *dp, int dev, + unsigned char *data, struct snd_seq_event *ev); -int snd_seq_oss_synth_make_info(seq_oss_devinfo_t *dp, int dev, struct synth_info *inf); +int snd_seq_oss_synth_make_info(struct seq_oss_devinfo *dp, int dev, struct synth_info *inf); #endif diff --git a/sound/core/seq/oss/seq_oss_timer.c b/sound/core/seq/oss/seq_oss_timer.c index 64d594b3170..c440fdacec9 100644 --- a/sound/core/seq/oss/seq_oss_timer.c +++ b/sound/core/seq/oss/seq_oss_timer.c @@ -33,18 +33,18 @@ /* */ -static void calc_alsa_tempo(seq_oss_timer_t *timer); -static int send_timer_event(seq_oss_devinfo_t *dp, int type, int value); +static void calc_alsa_tempo(struct seq_oss_timer *timer); +static int send_timer_event(struct seq_oss_devinfo *dp, int type, int value); /* * create and register a new timer. * if queue is not started yet, start it. */ -seq_oss_timer_t * -snd_seq_oss_timer_new(seq_oss_devinfo_t *dp) +struct seq_oss_timer * +snd_seq_oss_timer_new(struct seq_oss_devinfo *dp) { - seq_oss_timer_t *rec; + struct seq_oss_timer *rec; rec = kzalloc(sizeof(*rec), GFP_KERNEL); if (rec == NULL) @@ -67,7 +67,7 @@ snd_seq_oss_timer_new(seq_oss_devinfo_t *dp) * if no more timer exists, stop the queue. */ void -snd_seq_oss_timer_delete(seq_oss_timer_t *rec) +snd_seq_oss_timer_delete(struct seq_oss_timer *rec) { if (rec) { snd_seq_oss_timer_stop(rec); @@ -82,7 +82,7 @@ snd_seq_oss_timer_delete(seq_oss_timer_t *rec) * 0 : not a timer event -- enqueue this event */ int -snd_seq_oss_process_timer_event(seq_oss_timer_t *rec, evrec_t *ev) +snd_seq_oss_process_timer_event(struct seq_oss_timer *rec, union evrec *ev) { abstime_t parm = ev->t.time; @@ -125,7 +125,7 @@ snd_seq_oss_process_timer_event(seq_oss_timer_t *rec, evrec_t *ev) * convert tempo units */ static void -calc_alsa_tempo(seq_oss_timer_t *timer) +calc_alsa_tempo(struct seq_oss_timer *timer) { timer->tempo = (60 * 1000000) / timer->oss_tempo; timer->ppq = timer->oss_timebase; @@ -136,9 +136,9 @@ calc_alsa_tempo(seq_oss_timer_t *timer) * dispatch a timer event */ static int -send_timer_event(seq_oss_devinfo_t *dp, int type, int value) +send_timer_event(struct seq_oss_devinfo *dp, int type, int value) { - snd_seq_event_t ev; + struct snd_seq_event ev; memset(&ev, 0, sizeof(ev)); ev.type = type; @@ -156,10 +156,10 @@ send_timer_event(seq_oss_devinfo_t *dp, int type, int value) * set queue tempo and start queue */ int -snd_seq_oss_timer_start(seq_oss_timer_t *timer) +snd_seq_oss_timer_start(struct seq_oss_timer *timer) { - seq_oss_devinfo_t *dp = timer->dp; - snd_seq_queue_tempo_t tmprec; + struct seq_oss_devinfo *dp = timer->dp; + struct snd_seq_queue_tempo tmprec; if (timer->running) snd_seq_oss_timer_stop(timer); @@ -181,7 +181,7 @@ snd_seq_oss_timer_start(seq_oss_timer_t *timer) * stop queue */ int -snd_seq_oss_timer_stop(seq_oss_timer_t *timer) +snd_seq_oss_timer_stop(struct seq_oss_timer *timer) { if (! timer->running) return 0; @@ -195,7 +195,7 @@ snd_seq_oss_timer_stop(seq_oss_timer_t *timer) * continue queue */ int -snd_seq_oss_timer_continue(seq_oss_timer_t *timer) +snd_seq_oss_timer_continue(struct seq_oss_timer *timer) { if (timer->running) return 0; @@ -209,7 +209,7 @@ snd_seq_oss_timer_continue(seq_oss_timer_t *timer) * change queue tempo */ int -snd_seq_oss_timer_tempo(seq_oss_timer_t *timer, int value) +snd_seq_oss_timer_tempo(struct seq_oss_timer *timer, int value) { if (value < MIN_OSS_TEMPO) value = MIN_OSS_TEMPO; @@ -227,7 +227,7 @@ snd_seq_oss_timer_tempo(seq_oss_timer_t *timer, int value) * ioctls */ int -snd_seq_oss_timer_ioctl(seq_oss_timer_t *timer, unsigned int cmd, int __user *arg) +snd_seq_oss_timer_ioctl(struct seq_oss_timer *timer, unsigned int cmd, int __user *arg) { int value; diff --git a/sound/core/seq/oss/seq_oss_timer.h b/sound/core/seq/oss/seq_oss_timer.h index 6e4dbd8504c..b995bd68ad1 100644 --- a/sound/core/seq/oss/seq_oss_timer.h +++ b/sound/core/seq/oss/seq_oss_timer.h @@ -27,8 +27,8 @@ /* * timer information definition */ -struct seq_oss_timer_t { - seq_oss_devinfo_t *dp; +struct seq_oss_timer { + struct seq_oss_devinfo *dp; reltime_t cur_tick; int realtime; int running; @@ -37,22 +37,22 @@ struct seq_oss_timer_t { }; -seq_oss_timer_t *snd_seq_oss_timer_new(seq_oss_devinfo_t *dp); -void snd_seq_oss_timer_delete(seq_oss_timer_t *dp); +struct seq_oss_timer *snd_seq_oss_timer_new(struct seq_oss_devinfo *dp); +void snd_seq_oss_timer_delete(struct seq_oss_timer *dp); -int snd_seq_oss_timer_start(seq_oss_timer_t *timer); -int snd_seq_oss_timer_stop(seq_oss_timer_t *timer); -int snd_seq_oss_timer_continue(seq_oss_timer_t *timer); -int snd_seq_oss_timer_tempo(seq_oss_timer_t *timer, int value); +int snd_seq_oss_timer_start(struct seq_oss_timer *timer); +int snd_seq_oss_timer_stop(struct seq_oss_timer *timer); +int snd_seq_oss_timer_continue(struct seq_oss_timer *timer); +int snd_seq_oss_timer_tempo(struct seq_oss_timer *timer, int value); #define snd_seq_oss_timer_reset snd_seq_oss_timer_start -int snd_seq_oss_timer_ioctl(seq_oss_timer_t *timer, unsigned int cmd, int __user *arg); +int snd_seq_oss_timer_ioctl(struct seq_oss_timer *timer, unsigned int cmd, int __user *arg); /* * get current processed time */ static inline abstime_t -snd_seq_oss_timer_cur_tick(seq_oss_timer_t *timer) +snd_seq_oss_timer_cur_tick(struct seq_oss_timer *timer) { return timer->cur_tick; } @@ -62,7 +62,7 @@ snd_seq_oss_timer_cur_tick(seq_oss_timer_t *timer) * is realtime event? */ static inline int -snd_seq_oss_timer_is_realtime(seq_oss_timer_t *timer) +snd_seq_oss_timer_is_realtime(struct seq_oss_timer *timer) { return timer->realtime; } diff --git a/sound/core/seq/oss/seq_oss_writeq.c b/sound/core/seq/oss/seq_oss_writeq.c index b2037802454..5c8495601a3 100644 --- a/sound/core/seq/oss/seq_oss_writeq.c +++ b/sound/core/seq/oss/seq_oss_writeq.c @@ -32,11 +32,11 @@ /* * create a write queue record */ -seq_oss_writeq_t * -snd_seq_oss_writeq_new(seq_oss_devinfo_t *dp, int maxlen) +struct seq_oss_writeq * +snd_seq_oss_writeq_new(struct seq_oss_devinfo *dp, int maxlen) { - seq_oss_writeq_t *q; - snd_seq_client_pool_t pool; + struct seq_oss_writeq *q; + struct snd_seq_client_pool pool; if ((q = kzalloc(sizeof(*q), GFP_KERNEL)) == NULL) return NULL; @@ -61,7 +61,7 @@ snd_seq_oss_writeq_new(seq_oss_devinfo_t *dp, int maxlen) * delete the write queue */ void -snd_seq_oss_writeq_delete(seq_oss_writeq_t *q) +snd_seq_oss_writeq_delete(struct seq_oss_writeq *q) { snd_seq_oss_writeq_clear(q); /* to be sure */ kfree(q); @@ -72,9 +72,9 @@ snd_seq_oss_writeq_delete(seq_oss_writeq_t *q) * reset the write queue */ void -snd_seq_oss_writeq_clear(seq_oss_writeq_t *q) +snd_seq_oss_writeq_clear(struct seq_oss_writeq *q) { - snd_seq_remove_events_t reset; + struct snd_seq_remove_events reset; memset(&reset, 0, sizeof(reset)); reset.remove_mode = SNDRV_SEQ_REMOVE_OUTPUT; /* remove all */ @@ -88,9 +88,9 @@ snd_seq_oss_writeq_clear(seq_oss_writeq_t *q) * wait until the write buffer has enough room */ int -snd_seq_oss_writeq_sync(seq_oss_writeq_t *q) +snd_seq_oss_writeq_sync(struct seq_oss_writeq *q) { - seq_oss_devinfo_t *dp = q->dp; + struct seq_oss_devinfo *dp = q->dp; abstime_t time; time = snd_seq_oss_timer_cur_tick(dp->timer); @@ -98,8 +98,8 @@ snd_seq_oss_writeq_sync(seq_oss_writeq_t *q) return 0; /* already finished */ if (! q->sync_event_put) { - snd_seq_event_t ev; - evrec_t *rec; + struct snd_seq_event ev; + union evrec *rec; /* put echoback event */ memset(&ev, 0, sizeof(ev)); @@ -108,7 +108,7 @@ snd_seq_oss_writeq_sync(seq_oss_writeq_t *q) ev.time.tick = time; /* echo back to itself */ snd_seq_oss_fill_addr(dp, &ev, dp->addr.client, dp->addr.port); - rec = (evrec_t*)&ev.data; + rec = (union evrec *)&ev.data; rec->t.code = SEQ_SYNCTIMER; rec->t.time = time; q->sync_event_put = 1; @@ -128,7 +128,7 @@ snd_seq_oss_writeq_sync(seq_oss_writeq_t *q) * wake up sync - echo event was catched */ void -snd_seq_oss_writeq_wakeup(seq_oss_writeq_t *q, abstime_t time) +snd_seq_oss_writeq_wakeup(struct seq_oss_writeq *q, abstime_t time) { unsigned long flags; @@ -146,9 +146,9 @@ snd_seq_oss_writeq_wakeup(seq_oss_writeq_t *q, abstime_t time) * return the unused pool size */ int -snd_seq_oss_writeq_get_free_size(seq_oss_writeq_t *q) +snd_seq_oss_writeq_get_free_size(struct seq_oss_writeq *q) { - snd_seq_client_pool_t pool; + struct snd_seq_client_pool pool; pool.client = q->dp->cseq; snd_seq_oss_control(q->dp, SNDRV_SEQ_IOCTL_GET_CLIENT_POOL, &pool); return pool.output_free; @@ -159,9 +159,9 @@ snd_seq_oss_writeq_get_free_size(seq_oss_writeq_t *q) * set output threshold size from ioctl */ void -snd_seq_oss_writeq_set_output(seq_oss_writeq_t *q, int val) +snd_seq_oss_writeq_set_output(struct seq_oss_writeq *q, int val) { - snd_seq_client_pool_t pool; + struct snd_seq_client_pool pool; pool.client = q->dp->cseq; snd_seq_oss_control(q->dp, SNDRV_SEQ_IOCTL_GET_CLIENT_POOL, &pool); pool.output_room = val; diff --git a/sound/core/seq/oss/seq_oss_writeq.h b/sound/core/seq/oss/seq_oss_writeq.h index 6a13c85e239..c469d296756 100644 --- a/sound/core/seq/oss/seq_oss_writeq.h +++ b/sound/core/seq/oss/seq_oss_writeq.h @@ -25,8 +25,8 @@ #include "seq_oss_device.h" -struct seq_oss_writeq_t { - seq_oss_devinfo_t *dp; +struct seq_oss_writeq { + struct seq_oss_devinfo *dp; int maxlen; abstime_t sync_time; int sync_event_put; @@ -38,13 +38,13 @@ struct seq_oss_writeq_t { /* * seq_oss_writeq.c */ -seq_oss_writeq_t *snd_seq_oss_writeq_new(seq_oss_devinfo_t *dp, int maxlen); -void snd_seq_oss_writeq_delete(seq_oss_writeq_t *q); -void snd_seq_oss_writeq_clear(seq_oss_writeq_t *q); -int snd_seq_oss_writeq_sync(seq_oss_writeq_t *q); -void snd_seq_oss_writeq_wakeup(seq_oss_writeq_t *q, abstime_t time); -int snd_seq_oss_writeq_get_free_size(seq_oss_writeq_t *q); -void snd_seq_oss_writeq_set_output(seq_oss_writeq_t *q, int size); +struct seq_oss_writeq *snd_seq_oss_writeq_new(struct seq_oss_devinfo *dp, int maxlen); +void snd_seq_oss_writeq_delete(struct seq_oss_writeq *q); +void snd_seq_oss_writeq_clear(struct seq_oss_writeq *q); +int snd_seq_oss_writeq_sync(struct seq_oss_writeq *q); +void snd_seq_oss_writeq_wakeup(struct seq_oss_writeq *q, abstime_t time); +int snd_seq_oss_writeq_get_free_size(struct seq_oss_writeq *q); +void snd_seq_oss_writeq_set_output(struct seq_oss_writeq *q, int size); #endif diff --git a/sound/core/seq/seq.c b/sound/core/seq/seq.c index 24644150f24..20f954bc7aa 100644 --- a/sound/core/seq/seq.c +++ b/sound/core/seq/seq.c @@ -36,9 +36,9 @@ #include <sound/seq_device.h> #if defined(CONFIG_SND_SEQ_DUMMY_MODULE) -int seq_client_load[64] = {[0] = SNDRV_SEQ_CLIENT_DUMMY, [1 ... 63] = -1}; +int seq_client_load[15] = {[0] = SNDRV_SEQ_CLIENT_DUMMY, [1 ... 14] = -1}; #else -int seq_client_load[64] = {[0 ... 63] = -1}; +int seq_client_load[15] = {[0 ... 14] = -1}; #endif int seq_default_timer_class = SNDRV_TIMER_CLASS_GLOBAL; int seq_default_timer_sclass = SNDRV_TIMER_SCLASS_NONE; diff --git a/sound/core/seq/seq_clientmgr.c b/sound/core/seq/seq_clientmgr.c index a886db94b1f..fd2032eae21 100644 --- a/sound/core/seq/seq_clientmgr.c +++ b/sound/core/seq/seq_clientmgr.c @@ -47,6 +47,21 @@ * */ +/* + * There are four ranges of client numbers (last two shared): + * 0..15: global clients + * 16..127: statically allocated client numbers for cards 0..27 + * 128..191: dynamically allocated client numbers for cards 28..31 + * 128..191: dynamically allocated client numbers for applications + */ + +/* number of kernel non-card clients */ +#define SNDRV_SEQ_GLOBAL_CLIENTS 16 +/* clients per cards, for static clients */ +#define SNDRV_SEQ_CLIENTS_PER_CARD 4 +/* dynamically allocated client numbers (both kernel drivers and user space) */ +#define SNDRV_SEQ_DYNAMIC_CLIENTS_BEGIN 128 + #define SNDRV_SEQ_LFLG_INPUT 0x0001 #define SNDRV_SEQ_LFLG_OUTPUT 0x0002 #define SNDRV_SEQ_LFLG_OPEN (SNDRV_SEQ_LFLG_INPUT|SNDRV_SEQ_LFLG_OUTPUT) @@ -58,14 +73,18 @@ static DECLARE_MUTEX(register_mutex); * client table */ static char clienttablock[SNDRV_SEQ_MAX_CLIENTS]; -static client_t *clienttab[SNDRV_SEQ_MAX_CLIENTS]; -static usage_t client_usage; +static struct snd_seq_client *clienttab[SNDRV_SEQ_MAX_CLIENTS]; +static struct snd_seq_usage client_usage; /* * prototypes */ -static int bounce_error_event(client_t *client, snd_seq_event_t *event, int err, int atomic, int hop); -static int snd_seq_deliver_single_event(client_t *client, snd_seq_event_t *event, int filter, int atomic, int hop); +static int bounce_error_event(struct snd_seq_client *client, + struct snd_seq_event *event, + int err, int atomic, int hop); +static int snd_seq_deliver_single_event(struct snd_seq_client *client, + struct snd_seq_event *event, + int filter, int atomic, int hop); /* */ @@ -96,16 +115,17 @@ static inline unsigned short snd_seq_file_flags(struct file *file) } } -static inline int snd_seq_write_pool_allocated(client_t *client) +static inline int snd_seq_write_pool_allocated(struct snd_seq_client *client) { return snd_seq_total_cells(client->pool) > 0; } /* return pointer to client structure for specified id */ -static client_t *clientptr(int clientid) +static struct snd_seq_client *clientptr(int clientid) { if (clientid < 0 || clientid >= SNDRV_SEQ_MAX_CLIENTS) { - snd_printd("Seq: oops. Trying to get pointer to client %d\n", clientid); + snd_printd("Seq: oops. Trying to get pointer to client %d\n", + clientid); return NULL; } return clienttab[clientid]; @@ -113,13 +133,14 @@ static client_t *clientptr(int clientid) extern int seq_client_load[]; -client_t *snd_seq_client_use_ptr(int clientid) +struct snd_seq_client *snd_seq_client_use_ptr(int clientid) { unsigned long flags; - client_t *client; + struct snd_seq_client *client; if (clientid < 0 || clientid >= SNDRV_SEQ_MAX_CLIENTS) { - snd_printd("Seq: oops. Trying to get pointer to client %d\n", clientid); + snd_printd("Seq: oops. Trying to get pointer to client %d\n", + clientid); return NULL; } spin_lock_irqsave(&clients_lock, flags); @@ -133,24 +154,26 @@ client_t *snd_seq_client_use_ptr(int clientid) spin_unlock_irqrestore(&clients_lock, flags); #ifdef CONFIG_KMOD if (!in_interrupt() && current->fs->root) { - static char client_requested[64]; + static char client_requested[SNDRV_SEQ_GLOBAL_CLIENTS]; static char card_requested[SNDRV_CARDS]; - if (clientid < 64) { + if (clientid < SNDRV_SEQ_GLOBAL_CLIENTS) { int idx; if (! client_requested[clientid] && current->fs->root) { client_requested[clientid] = 1; - for (idx = 0; idx < 64; idx++) { + for (idx = 0; idx < 15; idx++) { if (seq_client_load[idx] < 0) break; if (seq_client_load[idx] == clientid) { - request_module("snd-seq-client-%i", clientid); + request_module("snd-seq-client-%i", + clientid); break; } } } - } else if (clientid >= 64 && clientid < 128) { - int card = (clientid - 64) / 8; + } else if (clientid < SNDRV_SEQ_DYNAMIC_CLIENTS_BEGIN) { + int card = (clientid - SNDRV_SEQ_GLOBAL_CLIENTS) / + SNDRV_SEQ_CLIENTS_PER_CARD; if (card < snd_ecards_limit) { if (! card_requested[card]) { card_requested[card] = 1; @@ -174,14 +197,14 @@ client_t *snd_seq_client_use_ptr(int clientid) return client; } -static void usage_alloc(usage_t * res, int num) +static void usage_alloc(struct snd_seq_usage *res, int num) { res->cur += num; if (res->cur > res->peak) res->peak = res->cur; } -static void usage_free(usage_t * res, int num) +static void usage_free(struct snd_seq_usage *res, int num) { res->cur -= num; } @@ -196,11 +219,11 @@ int __init client_init_data(void) } -static client_t *seq_create_client1(int client_index, int poolsize) +static struct snd_seq_client *seq_create_client1(int client_index, int poolsize) { unsigned long flags; int c; - client_t *client; + struct snd_seq_client *client; /* init client data */ client = kzalloc(sizeof(*client), GFP_KERNEL); @@ -220,7 +243,9 @@ static client_t *seq_create_client1(int client_index, int poolsize) /* find free slot in the client table */ spin_lock_irqsave(&clients_lock, flags); if (client_index < 0) { - for (c = 128; c < SNDRV_SEQ_MAX_CLIENTS; c++) { + for (c = SNDRV_SEQ_DYNAMIC_CLIENTS_BEGIN; + c < SNDRV_SEQ_MAX_CLIENTS; + c++) { if (clienttab[c] || clienttablock[c]) continue; clienttab[client->number = c] = client; @@ -241,7 +266,7 @@ static client_t *seq_create_client1(int client_index, int poolsize) } -static int seq_free_client1(client_t *client) +static int seq_free_client1(struct snd_seq_client *client) { unsigned long flags; @@ -263,12 +288,13 @@ static int seq_free_client1(client_t *client) } -static void seq_free_client(client_t * client) +static void seq_free_client(struct snd_seq_client * client) { down(®ister_mutex); switch (client->type) { case NO_CLIENT: - snd_printk(KERN_WARNING "Seq: Trying to free unused client %d\n", client->number); + snd_printk(KERN_WARNING "Seq: Trying to free unused client %d\n", + client->number); break; case USER_CLIENT: case KERNEL_CLIENT: @@ -277,7 +303,8 @@ static void seq_free_client(client_t * client) break; default: - snd_printk(KERN_ERR "Seq: Trying to free client %d with undefined type = %d\n", client->number, client->type); + snd_printk(KERN_ERR "Seq: Trying to free client %d with undefined type = %d\n", + client->number, client->type); } up(®ister_mutex); @@ -292,8 +319,8 @@ static void seq_free_client(client_t * client) static int snd_seq_open(struct inode *inode, struct file *file) { int c, mode; /* client id */ - client_t *client; - user_client_t *user; + struct snd_seq_client *client; + struct snd_seq_user_client *user; if (down_interruptible(®ister_mutex)) return -ERESTARTSYS; @@ -344,7 +371,7 @@ static int snd_seq_open(struct inode *inode, struct file *file) /* delete a user client */ static int snd_seq_release(struct inode *inode, struct file *file) { - client_t *client = (client_t *) file->private_data; + struct snd_seq_client *client = file->private_data; if (client) { seq_free_client(client); @@ -364,13 +391,14 @@ static int snd_seq_release(struct inode *inode, struct file *file) * -EINVAL no enough user-space buffer to write the whole event * -EFAULT seg. fault during copy to user space */ -static ssize_t snd_seq_read(struct file *file, char __user *buf, size_t count, loff_t *offset) +static ssize_t snd_seq_read(struct file *file, char __user *buf, size_t count, + loff_t *offset) { - client_t *client = (client_t *) file->private_data; - fifo_t *fifo; + struct snd_seq_client *client = file->private_data; + struct snd_seq_fifo *fifo; int err; long result = 0; - snd_seq_event_cell_t *cell; + struct snd_seq_event_cell *cell; if (!(snd_seq_file_flags(file) & SNDRV_SEQ_LFLG_INPUT)) return -ENXIO; @@ -396,7 +424,7 @@ static ssize_t snd_seq_read(struct file *file, char __user *buf, size_t count, l snd_seq_fifo_lock(fifo); /* while data available in queue */ - while (count >= sizeof(snd_seq_event_t)) { + while (count >= sizeof(struct snd_seq_event)) { int nonblock; nonblock = (file->f_flags & O_NONBLOCK) || result > 0; @@ -404,34 +432,34 @@ static ssize_t snd_seq_read(struct file *file, char __user *buf, size_t count, l break; } if (snd_seq_ev_is_variable(&cell->event)) { - snd_seq_event_t tmpev; + struct snd_seq_event tmpev; tmpev = cell->event; tmpev.data.ext.len &= ~SNDRV_SEQ_EXT_MASK; - if (copy_to_user(buf, &tmpev, sizeof(snd_seq_event_t))) { + if (copy_to_user(buf, &tmpev, sizeof(struct snd_seq_event))) { err = -EFAULT; break; } - count -= sizeof(snd_seq_event_t); - buf += sizeof(snd_seq_event_t); + count -= sizeof(struct snd_seq_event); + buf += sizeof(struct snd_seq_event); err = snd_seq_expand_var_event(&cell->event, count, (char __force *)buf, 0, - sizeof(snd_seq_event_t)); + sizeof(struct snd_seq_event)); if (err < 0) break; result += err; count -= err; buf += err; } else { - if (copy_to_user(buf, &cell->event, sizeof(snd_seq_event_t))) { + if (copy_to_user(buf, &cell->event, sizeof(struct snd_seq_event))) { err = -EFAULT; break; } - count -= sizeof(snd_seq_event_t); - buf += sizeof(snd_seq_event_t); + count -= sizeof(struct snd_seq_event); + buf += sizeof(struct snd_seq_event); } snd_seq_cell_free(cell); cell = NULL; /* to be sure */ - result += sizeof(snd_seq_event_t); + result += sizeof(struct snd_seq_event); } if (err < 0) { @@ -449,7 +477,7 @@ static ssize_t snd_seq_read(struct file *file, char __user *buf, size_t count, l /* * check access permission to the port */ -static int check_port_perm(client_port_t *port, unsigned int flags) +static int check_port_perm(struct snd_seq_client_port *port, unsigned int flags) { if ((port->capability & flags) != flags) return 0; @@ -460,9 +488,10 @@ static int check_port_perm(client_port_t *port, unsigned int flags) * check if the destination client is available, and return the pointer * if filter is non-zero, client filter bitmap is tested. */ -static client_t *get_event_dest_client(snd_seq_event_t *event, int filter) +static struct snd_seq_client *get_event_dest_client(struct snd_seq_event *event, + int filter) { - client_t *dest; + struct snd_seq_client *dest; dest = snd_seq_client_use_ptr(event->dest.client); if (dest == NULL) @@ -493,10 +522,11 @@ __not_avail: * quoted in SNDRV_SEQ_EVENT_KERNEL_ERROR, since this requires no extra * kmalloc. */ -static int bounce_error_event(client_t *client, snd_seq_event_t *event, +static int bounce_error_event(struct snd_seq_client *client, + struct snd_seq_event *event, int err, int atomic, int hop) { - snd_seq_event_t bounce_ev; + struct snd_seq_event bounce_ev; int result; if (client == NULL || @@ -531,9 +561,10 @@ static int bounce_error_event(client_t *client, snd_seq_event_t *event, * of the given queue. * return non-zero if updated. */ -static int update_timestamp_of_queue(snd_seq_event_t *event, int queue, int real_time) +static int update_timestamp_of_queue(struct snd_seq_event *event, + int queue, int real_time) { - queue_t *q; + struct snd_seq_queue *q; q = queueptr(queue); if (! q) @@ -559,12 +590,12 @@ static int update_timestamp_of_queue(snd_seq_event_t *event, int queue, int real * RETURN VALUE: 0 : if succeeded * <0 : error */ -static int snd_seq_deliver_single_event(client_t *client, - snd_seq_event_t *event, +static int snd_seq_deliver_single_event(struct snd_seq_client *client, + struct snd_seq_event *event, int filter, int atomic, int hop) { - client_t *dest = NULL; - client_port_t *dest_port = NULL; + struct snd_seq_client *dest = NULL; + struct snd_seq_client_port *dest_port = NULL; int result = -ENOENT; int direct; @@ -596,7 +627,9 @@ static int snd_seq_deliver_single_event(client_t *client, case KERNEL_CLIENT: if (dest_port->event_input == NULL) break; - result = dest_port->event_input(event, direct, dest_port->private_data, atomic, hop); + result = dest_port->event_input(event, direct, + dest_port->private_data, + atomic, hop); break; default: break; @@ -618,16 +651,16 @@ static int snd_seq_deliver_single_event(client_t *client, /* * send the event to all subscribers: */ -static int deliver_to_subscribers(client_t *client, - snd_seq_event_t *event, +static int deliver_to_subscribers(struct snd_seq_client *client, + struct snd_seq_event *event, int atomic, int hop) { - subscribers_t *subs; + struct snd_seq_subscribers *subs; int err = 0, num_ev = 0; - snd_seq_event_t event_saved; - client_port_t *src_port; + struct snd_seq_event event_saved; + struct snd_seq_client_port *src_port; struct list_head *p; - port_subs_info_t *grp; + struct snd_seq_port_subs_info *grp; src_port = snd_seq_port_use_ptr(client, event->source.port); if (src_port == NULL) @@ -642,7 +675,7 @@ static int deliver_to_subscribers(client_t *client, else down_read(&grp->list_mutex); list_for_each(p, &grp->list_head) { - subs = list_entry(p, subscribers_t, src_list); + subs = list_entry(p, struct snd_seq_subscribers, src_list); event->dest = subs->info.dest; if (subs->info.flags & SNDRV_SEQ_PORT_SUBS_TIMESTAMP) /* convert time according to flag with subscription */ @@ -670,12 +703,12 @@ static int deliver_to_subscribers(client_t *client, /* * broadcast to all ports: */ -static int port_broadcast_event(client_t *client, - snd_seq_event_t *event, +static int port_broadcast_event(struct snd_seq_client *client, + struct snd_seq_event *event, int atomic, int hop) { int num_ev = 0, err = 0; - client_t *dest_client; + struct snd_seq_client *dest_client; struct list_head *p; dest_client = get_event_dest_client(event, SNDRV_SEQ_FILTER_BROADCAST); @@ -684,7 +717,7 @@ static int port_broadcast_event(client_t *client, read_lock(&dest_client->ports_lock); list_for_each(p, &dest_client->ports_list_head) { - client_port_t *port = list_entry(p, client_port_t, list); + struct snd_seq_client_port *port = list_entry(p, struct snd_seq_client_port, list); event->dest.port = port->addr.port; /* pass NULL as source client to avoid error bounce */ err = snd_seq_deliver_single_event(NULL, event, @@ -704,12 +737,12 @@ static int port_broadcast_event(client_t *client, * send the event to all clients: * if destination port is also ADDRESS_BROADCAST, deliver to all ports. */ -static int broadcast_event(client_t *client, - snd_seq_event_t *event, int atomic, int hop) +static int broadcast_event(struct snd_seq_client *client, + struct snd_seq_event *event, int atomic, int hop) { int err = 0, num_ev = 0; int dest; - snd_seq_addr_t addr; + struct snd_seq_addr addr; addr = event->dest; /* save */ @@ -736,7 +769,7 @@ static int broadcast_event(client_t *client, /* multicast - not supported yet */ -static int multicast_event(client_t *client, snd_seq_event_t *event, +static int multicast_event(struct snd_seq_client *client, struct snd_seq_event *event, int atomic, int hop) { snd_printd("seq: multicast not supported yet.\n"); @@ -753,7 +786,7 @@ static int multicast_event(client_t *client, snd_seq_event_t *event, * n == 0 : the event was not passed to any client. * n < 0 : error - event was not processed. */ -static int snd_seq_deliver_event(client_t *client, snd_seq_event_t *event, +static int snd_seq_deliver_event(struct snd_seq_client *client, struct snd_seq_event *event, int atomic, int hop) { int result; @@ -794,9 +827,9 @@ static int snd_seq_deliver_event(client_t *client, snd_seq_event_t *event, * n == 0 : the event was not passed to any client. * n < 0 : error - event was not processed. */ -int snd_seq_dispatch_event(snd_seq_event_cell_t *cell, int atomic, int hop) +int snd_seq_dispatch_event(struct snd_seq_event_cell *cell, int atomic, int hop) { - client_t *client; + struct snd_seq_client *client; int result; snd_assert(cell != NULL, return -EINVAL); @@ -812,7 +845,7 @@ int snd_seq_dispatch_event(snd_seq_event_cell_t *cell, int atomic, int hop) * the event cell is re-used as a NOTE-OFF event and * enqueued again. */ - snd_seq_event_t tmpev, *ev; + struct snd_seq_event tmpev, *ev; /* reserve this event to enqueue note-off later */ tmpev = cell->event; @@ -865,12 +898,12 @@ int snd_seq_dispatch_event(snd_seq_event_cell_t *cell, int atomic, int hop) * if pool is empty and blocking is TRUE, sleep until a new cell is * available. */ -static int snd_seq_client_enqueue_event(client_t *client, - snd_seq_event_t *event, +static int snd_seq_client_enqueue_event(struct snd_seq_client *client, + struct snd_seq_event *event, struct file *file, int blocking, int atomic, int hop) { - snd_seq_event_cell_t *cell; + struct snd_seq_event_cell *cell; int err; /* special queue values - force direct passing */ @@ -886,7 +919,7 @@ static int snd_seq_client_enqueue_event(client_t *client, #endif if (event->dest.client == SNDRV_SEQ_ADDRESS_SUBSCRIBERS) { /* check presence of source port */ - client_port_t *src_port = snd_seq_port_use_ptr(client, event->source.port); + struct snd_seq_client_port *src_port = snd_seq_port_use_ptr(client, event->source.port); if (src_port == NULL) return -EINVAL; snd_seq_port_unlock(src_port); @@ -924,7 +957,7 @@ static int snd_seq_client_enqueue_event(client_t *client, * check validity of event type and data length. * return non-zero if invalid. */ -static int check_event_type_and_length(snd_seq_event_t *ev) +static int check_event_type_and_length(struct snd_seq_event *ev) { switch (snd_seq_ev_length_type(ev)) { case SNDRV_SEQ_EVENT_LENGTH_FIXED: @@ -957,12 +990,13 @@ static int check_event_type_and_length(snd_seq_event_t *ev) * -EMLINK too many hops * others depends on return value from driver callback */ -static ssize_t snd_seq_write(struct file *file, const char __user *buf, size_t count, loff_t *offset) +static ssize_t snd_seq_write(struct file *file, const char __user *buf, + size_t count, loff_t *offset) { - client_t *client = (client_t *) file->private_data; + struct snd_seq_client *client = file->private_data; int written = 0, len; int err = -EINVAL; - snd_seq_event_t event; + struct snd_seq_event event; if (!(snd_seq_file_flags(file) & SNDRV_SEQ_LFLG_OUTPUT)) return -ENXIO; @@ -980,7 +1014,7 @@ static ssize_t snd_seq_write(struct file *file, const char __user *buf, size_t c } /* only process whole events */ - while (count >= sizeof(snd_seq_event_t)) { + while (count >= sizeof(struct snd_seq_event)) { /* Read in the event header from the user */ len = sizeof(event); if (copy_from_user(&event, buf, len)) { @@ -1012,7 +1046,7 @@ static ssize_t snd_seq_write(struct file *file, const char __user *buf, size_t c /* set user space pointer */ event.data.ext.len = extlen | SNDRV_SEQ_EXT_USRPTR; event.data.ext.ptr = (char __force *)buf - + sizeof(snd_seq_event_t); + + sizeof(struct snd_seq_event); len += extlen; /* increment data length */ } else { #ifdef CONFIG_COMPAT @@ -1046,7 +1080,7 @@ static ssize_t snd_seq_write(struct file *file, const char __user *buf, size_t c */ static unsigned int snd_seq_poll(struct file *file, poll_table * wait) { - client_t *client = (client_t *) file->private_data; + struct snd_seq_client *client = file->private_data; unsigned int mask = 0; /* check client structures are in place */ @@ -1076,9 +1110,9 @@ static unsigned int snd_seq_poll(struct file *file, poll_table * wait) /* SYSTEM_INFO ioctl() */ -static int snd_seq_ioctl_system_info(client_t *client, void __user *arg) +static int snd_seq_ioctl_system_info(struct snd_seq_client *client, void __user *arg) { - snd_seq_system_info_t info; + struct snd_seq_system_info info; memset(&info, 0, sizeof(info)); /* fill the info fields */ @@ -1096,10 +1130,10 @@ static int snd_seq_ioctl_system_info(client_t *client, void __user *arg) /* RUNNING_MODE ioctl() */ -static int snd_seq_ioctl_running_mode(client_t *client, void __user *arg) +static int snd_seq_ioctl_running_mode(struct snd_seq_client *client, void __user *arg) { - struct sndrv_seq_running_info info; - client_t *cptr; + struct snd_seq_running_info info; + struct snd_seq_client *cptr; int err = 0; if (copy_from_user(&info, arg, sizeof(info))) @@ -1133,7 +1167,8 @@ static int snd_seq_ioctl_running_mode(client_t *client, void __user *arg) } /* CLIENT_INFO ioctl() */ -static void get_client_info(client_t *cptr, snd_seq_client_info_t *info) +static void get_client_info(struct snd_seq_client *cptr, + struct snd_seq_client_info *info) { info->client = cptr->number; @@ -1147,10 +1182,11 @@ static void get_client_info(client_t *cptr, snd_seq_client_info_t *info) memset(info->reserved, 0, sizeof(info->reserved)); } -static int snd_seq_ioctl_get_client_info(client_t * client, void __user *arg) +static int snd_seq_ioctl_get_client_info(struct snd_seq_client *client, + void __user *arg) { - client_t *cptr; - snd_seq_client_info_t client_info; + struct snd_seq_client *cptr; + struct snd_seq_client_info client_info; if (copy_from_user(&client_info, arg, sizeof(client_info))) return -EFAULT; @@ -1170,9 +1206,10 @@ static int snd_seq_ioctl_get_client_info(client_t * client, void __user *arg) /* CLIENT_INFO ioctl() */ -static int snd_seq_ioctl_set_client_info(client_t * client, void __user *arg) +static int snd_seq_ioctl_set_client_info(struct snd_seq_client *client, + void __user *arg) { - snd_seq_client_info_t client_info; + struct snd_seq_client_info client_info; if (copy_from_user(&client_info, arg, sizeof(client_info))) return -EFAULT; @@ -1199,11 +1236,12 @@ static int snd_seq_ioctl_set_client_info(client_t * client, void __user *arg) /* * CREATE PORT ioctl() */ -static int snd_seq_ioctl_create_port(client_t * client, void __user *arg) +static int snd_seq_ioctl_create_port(struct snd_seq_client *client, + void __user *arg) { - client_port_t *port; - snd_seq_port_info_t info; - snd_seq_port_callback_t *callback; + struct snd_seq_client_port *port; + struct snd_seq_port_info info; + struct snd_seq_port_callback *callback; if (copy_from_user(&info, arg, sizeof(info))) return -EFAULT; @@ -1249,9 +1287,10 @@ static int snd_seq_ioctl_create_port(client_t * client, void __user *arg) /* * DELETE PORT ioctl() */ -static int snd_seq_ioctl_delete_port(client_t * client, void __user *arg) +static int snd_seq_ioctl_delete_port(struct snd_seq_client *client, + void __user *arg) { - snd_seq_port_info_t info; + struct snd_seq_port_info info; int err; /* set passed parameters */ @@ -1272,11 +1311,12 @@ static int snd_seq_ioctl_delete_port(client_t * client, void __user *arg) /* * GET_PORT_INFO ioctl() (on any client) */ -static int snd_seq_ioctl_get_port_info(client_t *client, void __user *arg) +static int snd_seq_ioctl_get_port_info(struct snd_seq_client *client, + void __user *arg) { - client_t *cptr; - client_port_t *port; - snd_seq_port_info_t info; + struct snd_seq_client *cptr; + struct snd_seq_client_port *port; + struct snd_seq_port_info info; if (copy_from_user(&info, arg, sizeof(info))) return -EFAULT; @@ -1304,10 +1344,11 @@ static int snd_seq_ioctl_get_port_info(client_t *client, void __user *arg) /* * SET_PORT_INFO ioctl() (only ports on this/own client) */ -static int snd_seq_ioctl_set_port_info(client_t * client, void __user *arg) +static int snd_seq_ioctl_set_port_info(struct snd_seq_client *client, + void __user *arg) { - client_port_t *port; - snd_seq_port_info_t info; + struct snd_seq_client_port *port; + struct snd_seq_port_info info; if (copy_from_user(&info, arg, sizeof(info))) return -EFAULT; @@ -1329,9 +1370,10 @@ static int snd_seq_ioctl_set_port_info(client_t * client, void __user *arg) #define PERM_RD (SNDRV_SEQ_PORT_CAP_READ|SNDRV_SEQ_PORT_CAP_SUBS_READ) #define PERM_WR (SNDRV_SEQ_PORT_CAP_WRITE|SNDRV_SEQ_PORT_CAP_SUBS_WRITE) -static int check_subscription_permission(client_t *client, client_port_t *sport, - client_port_t *dport, - snd_seq_port_subscribe_t *subs) +static int check_subscription_permission(struct snd_seq_client *client, + struct snd_seq_client_port *sport, + struct snd_seq_client_port *dport, + struct snd_seq_port_subscribe *subs) { if (client->number != subs->sender.client && client->number != subs->dest.client) { @@ -1363,9 +1405,10 @@ static int check_subscription_permission(client_t *client, client_port_t *sport, * client must be user client. */ int snd_seq_client_notify_subscription(int client, int port, - snd_seq_port_subscribe_t *info, int evtype) + struct snd_seq_port_subscribe *info, + int evtype) { - snd_seq_event_t event; + struct snd_seq_event event; memset(&event, 0, sizeof(event)); event.type = evtype; @@ -1379,12 +1422,13 @@ int snd_seq_client_notify_subscription(int client, int port, /* * add to port's subscription list IOCTL interface */ -static int snd_seq_ioctl_subscribe_port(client_t * client, void __user *arg) +static int snd_seq_ioctl_subscribe_port(struct snd_seq_client *client, + void __user *arg) { int result = -EINVAL; - client_t *receiver = NULL, *sender = NULL; - client_port_t *sport = NULL, *dport = NULL; - snd_seq_port_subscribe_t subs; + struct snd_seq_client *receiver = NULL, *sender = NULL; + struct snd_seq_client_port *sport = NULL, *dport = NULL; + struct snd_seq_port_subscribe subs; if (copy_from_user(&subs, arg, sizeof(subs))) return -EFAULT; @@ -1423,12 +1467,13 @@ static int snd_seq_ioctl_subscribe_port(client_t * client, void __user *arg) /* * remove from port's subscription list */ -static int snd_seq_ioctl_unsubscribe_port(client_t * client, void __user *arg) +static int snd_seq_ioctl_unsubscribe_port(struct snd_seq_client *client, + void __user *arg) { int result = -ENXIO; - client_t *receiver = NULL, *sender = NULL; - client_port_t *sport = NULL, *dport = NULL; - snd_seq_port_subscribe_t subs; + struct snd_seq_client *receiver = NULL, *sender = NULL; + struct snd_seq_client_port *sport = NULL, *dport = NULL; + struct snd_seq_port_subscribe subs; if (copy_from_user(&subs, arg, sizeof(subs))) return -EFAULT; @@ -1464,11 +1509,12 @@ static int snd_seq_ioctl_unsubscribe_port(client_t * client, void __user *arg) /* CREATE_QUEUE ioctl() */ -static int snd_seq_ioctl_create_queue(client_t *client, void __user *arg) +static int snd_seq_ioctl_create_queue(struct snd_seq_client *client, + void __user *arg) { - snd_seq_queue_info_t info; + struct snd_seq_queue_info info; int result; - queue_t *q; + struct snd_seq_queue *q; if (copy_from_user(&info, arg, sizeof(info))) return -EFAULT; @@ -1498,9 +1544,10 @@ static int snd_seq_ioctl_create_queue(client_t *client, void __user *arg) } /* DELETE_QUEUE ioctl() */ -static int snd_seq_ioctl_delete_queue(client_t *client, void __user *arg) +static int snd_seq_ioctl_delete_queue(struct snd_seq_client *client, + void __user *arg) { - snd_seq_queue_info_t info; + struct snd_seq_queue_info info; if (copy_from_user(&info, arg, sizeof(info))) return -EFAULT; @@ -1509,10 +1556,11 @@ static int snd_seq_ioctl_delete_queue(client_t *client, void __user *arg) } /* GET_QUEUE_INFO ioctl() */ -static int snd_seq_ioctl_get_queue_info(client_t *client, void __user *arg) +static int snd_seq_ioctl_get_queue_info(struct snd_seq_client *client, + void __user *arg) { - snd_seq_queue_info_t info; - queue_t *q; + struct snd_seq_queue_info info; + struct snd_seq_queue *q; if (copy_from_user(&info, arg, sizeof(info))) return -EFAULT; @@ -1535,10 +1583,11 @@ static int snd_seq_ioctl_get_queue_info(client_t *client, void __user *arg) } /* SET_QUEUE_INFO ioctl() */ -static int snd_seq_ioctl_set_queue_info(client_t *client, void __user *arg) +static int snd_seq_ioctl_set_queue_info(struct snd_seq_client *client, + void __user *arg) { - snd_seq_queue_info_t info; - queue_t *q; + struct snd_seq_queue_info info; + struct snd_seq_queue *q; if (copy_from_user(&info, arg, sizeof(info))) return -EFAULT; @@ -1570,10 +1619,10 @@ static int snd_seq_ioctl_set_queue_info(client_t *client, void __user *arg) } /* GET_NAMED_QUEUE ioctl() */ -static int snd_seq_ioctl_get_named_queue(client_t *client, void __user *arg) +static int snd_seq_ioctl_get_named_queue(struct snd_seq_client *client, void __user *arg) { - snd_seq_queue_info_t info; - queue_t *q; + struct snd_seq_queue_info info; + struct snd_seq_queue *q; if (copy_from_user(&info, arg, sizeof(info))) return -EFAULT; @@ -1593,11 +1642,12 @@ static int snd_seq_ioctl_get_named_queue(client_t *client, void __user *arg) } /* GET_QUEUE_STATUS ioctl() */ -static int snd_seq_ioctl_get_queue_status(client_t * client, void __user *arg) +static int snd_seq_ioctl_get_queue_status(struct snd_seq_client *client, + void __user *arg) { - snd_seq_queue_status_t status; - queue_t *queue; - seq_timer_t *tmr; + struct snd_seq_queue_status status; + struct snd_seq_queue *queue; + struct snd_seq_timer *tmr; if (copy_from_user(&status, arg, sizeof(status))) return -EFAULT; @@ -1626,11 +1676,12 @@ static int snd_seq_ioctl_get_queue_status(client_t * client, void __user *arg) /* GET_QUEUE_TEMPO ioctl() */ -static int snd_seq_ioctl_get_queue_tempo(client_t * client, void __user *arg) +static int snd_seq_ioctl_get_queue_tempo(struct snd_seq_client *client, + void __user *arg) { - snd_seq_queue_tempo_t tempo; - queue_t *queue; - seq_timer_t *tmr; + struct snd_seq_queue_tempo tempo; + struct snd_seq_queue *queue; + struct snd_seq_timer *tmr; if (copy_from_user(&tempo, arg, sizeof(tempo))) return -EFAULT; @@ -1656,17 +1707,18 @@ static int snd_seq_ioctl_get_queue_tempo(client_t * client, void __user *arg) /* SET_QUEUE_TEMPO ioctl() */ -int snd_seq_set_queue_tempo(int client, snd_seq_queue_tempo_t *tempo) +int snd_seq_set_queue_tempo(int client, struct snd_seq_queue_tempo *tempo) { if (!snd_seq_queue_check_access(tempo->queue, client)) return -EPERM; return snd_seq_queue_timer_set_tempo(tempo->queue, client, tempo); } -static int snd_seq_ioctl_set_queue_tempo(client_t * client, void __user *arg) +static int snd_seq_ioctl_set_queue_tempo(struct snd_seq_client *client, + void __user *arg) { int result; - snd_seq_queue_tempo_t tempo; + struct snd_seq_queue_tempo tempo; if (copy_from_user(&tempo, arg, sizeof(tempo))) return -EFAULT; @@ -1677,11 +1729,12 @@ static int snd_seq_ioctl_set_queue_tempo(client_t * client, void __user *arg) /* GET_QUEUE_TIMER ioctl() */ -static int snd_seq_ioctl_get_queue_timer(client_t * client, void __user *arg) +static int snd_seq_ioctl_get_queue_timer(struct snd_seq_client *client, + void __user *arg) { - snd_seq_queue_timer_t timer; - queue_t *queue; - seq_timer_t *tmr; + struct snd_seq_queue_timer timer; + struct snd_seq_queue *queue; + struct snd_seq_timer *tmr; if (copy_from_user(&timer, arg, sizeof(timer))) return -EFAULT; @@ -1713,10 +1766,11 @@ static int snd_seq_ioctl_get_queue_timer(client_t * client, void __user *arg) /* SET_QUEUE_TIMER ioctl() */ -static int snd_seq_ioctl_set_queue_timer(client_t * client, void __user *arg) +static int snd_seq_ioctl_set_queue_timer(struct snd_seq_client *client, + void __user *arg) { int result = 0; - snd_seq_queue_timer_t timer; + struct snd_seq_queue_timer timer; if (copy_from_user(&timer, arg, sizeof(timer))) return -EFAULT; @@ -1725,8 +1779,8 @@ static int snd_seq_ioctl_set_queue_timer(client_t * client, void __user *arg) return -EINVAL; if (snd_seq_queue_check_access(timer.queue, client->number)) { - queue_t *q; - seq_timer_t *tmr; + struct snd_seq_queue *q; + struct snd_seq_timer *tmr; q = queueptr(timer.queue); if (q == NULL) @@ -1754,9 +1808,10 @@ static int snd_seq_ioctl_set_queue_timer(client_t * client, void __user *arg) /* GET_QUEUE_CLIENT ioctl() */ -static int snd_seq_ioctl_get_queue_client(client_t * client, void __user *arg) +static int snd_seq_ioctl_get_queue_client(struct snd_seq_client *client, + void __user *arg) { - snd_seq_queue_client_t info; + struct snd_seq_queue_client info; int used; if (copy_from_user(&info, arg, sizeof(info))) @@ -1775,10 +1830,11 @@ static int snd_seq_ioctl_get_queue_client(client_t * client, void __user *arg) /* SET_QUEUE_CLIENT ioctl() */ -static int snd_seq_ioctl_set_queue_client(client_t * client, void __user *arg) +static int snd_seq_ioctl_set_queue_client(struct snd_seq_client *client, + void __user *arg) { int err; - snd_seq_queue_client_t info; + struct snd_seq_queue_client info; if (copy_from_user(&info, arg, sizeof(info))) return -EFAULT; @@ -1794,10 +1850,11 @@ static int snd_seq_ioctl_set_queue_client(client_t * client, void __user *arg) /* GET_CLIENT_POOL ioctl() */ -static int snd_seq_ioctl_get_client_pool(client_t * client, void __user *arg) +static int snd_seq_ioctl_get_client_pool(struct snd_seq_client *client, + void __user *arg) { - snd_seq_client_pool_t info; - client_t *cptr; + struct snd_seq_client_pool info; + struct snd_seq_client *cptr; if (copy_from_user(&info, arg, sizeof(info))) return -EFAULT; @@ -1828,9 +1885,10 @@ static int snd_seq_ioctl_get_client_pool(client_t * client, void __user *arg) } /* SET_CLIENT_POOL ioctl() */ -static int snd_seq_ioctl_set_client_pool(client_t * client, void __user *arg) +static int snd_seq_ioctl_set_client_pool(struct snd_seq_client *client, + void __user *arg) { - snd_seq_client_pool_t info; + struct snd_seq_client_pool info; int rc; if (copy_from_user(&info, arg, sizeof(info))) @@ -1872,9 +1930,10 @@ static int snd_seq_ioctl_set_client_pool(client_t * client, void __user *arg) /* REMOVE_EVENTS ioctl() */ -static int snd_seq_ioctl_remove_events(client_t * client, void __user *arg) +static int snd_seq_ioctl_remove_events(struct snd_seq_client *client, + void __user *arg) { - snd_seq_remove_events_t info; + struct snd_seq_remove_events info; if (copy_from_user(&info, arg, sizeof(info))) return -EFAULT; @@ -1901,13 +1960,14 @@ static int snd_seq_ioctl_remove_events(client_t * client, void __user *arg) /* * get subscription info */ -static int snd_seq_ioctl_get_subscription(client_t *client, void __user *arg) +static int snd_seq_ioctl_get_subscription(struct snd_seq_client *client, + void __user *arg) { int result; - client_t *sender = NULL; - client_port_t *sport = NULL; - snd_seq_port_subscribe_t subs; - subscribers_t *p; + struct snd_seq_client *sender = NULL; + struct snd_seq_client_port *sport = NULL; + struct snd_seq_port_subscribe subs; + struct snd_seq_subscribers *p; if (copy_from_user(&subs, arg, sizeof(subs))) return -EFAULT; @@ -1940,13 +2000,14 @@ static int snd_seq_ioctl_get_subscription(client_t *client, void __user *arg) /* * get subscription info - check only its presence */ -static int snd_seq_ioctl_query_subs(client_t *client, void __user *arg) +static int snd_seq_ioctl_query_subs(struct snd_seq_client *client, + void __user *arg) { int result = -ENXIO; - client_t *cptr = NULL; - client_port_t *port = NULL; - snd_seq_query_subs_t subs; - port_subs_info_t *group; + struct snd_seq_client *cptr = NULL; + struct snd_seq_client_port *port = NULL; + struct snd_seq_query_subs subs; + struct snd_seq_port_subs_info *group; struct list_head *p; int i; @@ -1977,12 +2038,12 @@ static int snd_seq_ioctl_query_subs(client_t *client, void __user *arg) list_for_each(p, &group->list_head) { if (i++ == subs.index) { /* found! */ - subscribers_t *s; + struct snd_seq_subscribers *s; if (subs.type == SNDRV_SEQ_QUERY_SUBS_READ) { - s = list_entry(p, subscribers_t, src_list); + s = list_entry(p, struct snd_seq_subscribers, src_list); subs.addr = s->info.dest; } else { - s = list_entry(p, subscribers_t, dest_list); + s = list_entry(p, struct snd_seq_subscribers, dest_list); subs.addr = s->info.sender; } subs.flags = s->info.flags; @@ -2009,10 +2070,11 @@ static int snd_seq_ioctl_query_subs(client_t *client, void __user *arg) /* * query next client */ -static int snd_seq_ioctl_query_next_client(client_t *client, void __user *arg) +static int snd_seq_ioctl_query_next_client(struct snd_seq_client *client, + void __user *arg) { - client_t *cptr = NULL; - snd_seq_client_info_t info; + struct snd_seq_client *cptr = NULL; + struct snd_seq_client_info info; if (copy_from_user(&info, arg, sizeof(info))) return -EFAULT; @@ -2040,11 +2102,12 @@ static int snd_seq_ioctl_query_next_client(client_t *client, void __user *arg) /* * query next port */ -static int snd_seq_ioctl_query_next_port(client_t *client, void __user *arg) +static int snd_seq_ioctl_query_next_port(struct snd_seq_client *client, + void __user *arg) { - client_t *cptr; - client_port_t *port = NULL; - snd_seq_port_info_t info; + struct snd_seq_client *cptr; + struct snd_seq_client_port *port = NULL; + struct snd_seq_port_info info; if (copy_from_user(&info, arg, sizeof(info))) return -EFAULT; @@ -2075,7 +2138,7 @@ static int snd_seq_ioctl_query_next_port(client_t *client, void __user *arg) static struct seq_ioctl_table { unsigned int cmd; - int (*func)(client_t *client, void __user * arg); + int (*func)(struct snd_seq_client *client, void __user * arg); } ioctl_tables[] = { { SNDRV_SEQ_IOCTL_SYSTEM_INFO, snd_seq_ioctl_system_info }, { SNDRV_SEQ_IOCTL_RUNNING_MODE, snd_seq_ioctl_running_mode }, @@ -2109,7 +2172,8 @@ static struct seq_ioctl_table { { 0, NULL }, }; -static int snd_seq_do_ioctl(client_t *client, unsigned int cmd, void __user *arg) +static int snd_seq_do_ioctl(struct snd_seq_client *client, unsigned int cmd, + void __user *arg) { struct seq_ioctl_table *p; @@ -2136,7 +2200,7 @@ static int snd_seq_do_ioctl(client_t *client, unsigned int cmd, void __user *arg static long snd_seq_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { - client_t *client = (client_t *) file->private_data; + struct snd_seq_client *client = file->private_data; snd_assert(client != NULL, return -ENXIO); @@ -2153,23 +2217,29 @@ static long snd_seq_ioctl(struct file *file, unsigned int cmd, unsigned long arg /* exported to kernel modules */ -int snd_seq_create_kernel_client(snd_card_t *card, int client_index, snd_seq_client_callback_t * callback) +int snd_seq_create_kernel_client(struct snd_card *card, int client_index, + const char *name_fmt, ...) { - client_t *client; + struct snd_seq_client *client; + va_list args; snd_assert(! in_interrupt(), return -EBUSY); - if (callback == NULL) + if (card && client_index >= SNDRV_SEQ_CLIENTS_PER_CARD) return -EINVAL; - if (card && client_index > 7) + if (card == NULL && client_index >= SNDRV_SEQ_GLOBAL_CLIENTS) return -EINVAL; - if (card == NULL && client_index > 63) - return -EINVAL; - if (card) - client_index += 64 + (card->number << 3); if (down_interruptible(®ister_mutex)) return -ERESTARTSYS; + + if (card) { + client_index += SNDRV_SEQ_GLOBAL_CLIENTS + + card->number * SNDRV_SEQ_CLIENTS_PER_CARD; + if (client_index >= SNDRV_SEQ_DYNAMIC_CLIENTS_BEGIN) + client_index = -1; + } + /* empty write queue as default */ client = seq_create_client1(client_index, 0); if (client == NULL) { @@ -2178,13 +2248,12 @@ int snd_seq_create_kernel_client(snd_card_t *card, int client_index, snd_seq_cli } usage_alloc(&client_usage, 1); - client->accept_input = callback->allow_output; - client->accept_output = callback->allow_input; + client->accept_input = 1; + client->accept_output = 1; - /* fill client data */ - client->data.kernel.card = card; - client->data.kernel.private_data = callback->private_data; - sprintf(client->name, "Client-%d", client->number); + va_start(args, name_fmt); + vsnprintf(client->name, sizeof(client->name), name_fmt, args); + va_end(args); client->type = KERNEL_CLIENT; up(®ister_mutex); @@ -2199,7 +2268,7 @@ int snd_seq_create_kernel_client(snd_card_t *card, int client_index, snd_seq_cli /* exported to kernel modules */ int snd_seq_delete_kernel_client(int client) { - client_t *ptr; + struct snd_seq_client *ptr; snd_assert(! in_interrupt(), return -EBUSY); @@ -2216,11 +2285,11 @@ int snd_seq_delete_kernel_client(int client) /* skeleton to enqueue event, called from snd_seq_kernel_client_enqueue * and snd_seq_kernel_client_enqueue_blocking */ -static int kernel_client_enqueue(int client, snd_seq_event_t *ev, +static int kernel_client_enqueue(int client, struct snd_seq_event *ev, struct file *file, int blocking, int atomic, int hop) { - client_t *cptr; + struct snd_seq_client *cptr; int result; snd_assert(ev != NULL, return -EINVAL); @@ -2254,7 +2323,7 @@ static int kernel_client_enqueue(int client, snd_seq_event_t *ev, * * RETURN VALUE: zero if succeed, negative if error */ -int snd_seq_kernel_client_enqueue(int client, snd_seq_event_t * ev, +int snd_seq_kernel_client_enqueue(int client, struct snd_seq_event * ev, int atomic, int hop) { return kernel_client_enqueue(client, ev, NULL, 0, atomic, hop); @@ -2265,7 +2334,7 @@ int snd_seq_kernel_client_enqueue(int client, snd_seq_event_t * ev, * * RETURN VALUE: zero if succeed, negative if error */ -int snd_seq_kernel_client_enqueue_blocking(int client, snd_seq_event_t * ev, +int snd_seq_kernel_client_enqueue_blocking(int client, struct snd_seq_event * ev, struct file *file, int atomic, int hop) { @@ -2280,10 +2349,10 @@ int snd_seq_kernel_client_enqueue_blocking(int client, snd_seq_event_t * ev, * RETURN VALUE: negative = delivery failed, * zero, or positive: the number of delivered events */ -int snd_seq_kernel_client_dispatch(int client, snd_seq_event_t * ev, +int snd_seq_kernel_client_dispatch(int client, struct snd_seq_event * ev, int atomic, int hop) { - client_t *cptr; + struct snd_seq_client *cptr; int result; snd_assert(ev != NULL, return -EINVAL); @@ -2315,7 +2384,7 @@ int snd_seq_kernel_client_dispatch(int client, snd_seq_event_t * ev, */ int snd_seq_kernel_client_ctl(int clientid, unsigned int cmd, void *arg) { - client_t *client; + struct snd_seq_client *client; mm_segment_t fs; int result; @@ -2332,7 +2401,7 @@ int snd_seq_kernel_client_ctl(int clientid, unsigned int cmd, void *arg) /* exported (for OSS emulator) */ int snd_seq_kernel_client_write_poll(int clientid, struct file *file, poll_table *wait) { - client_t *client; + struct snd_seq_client *client; client = clientptr(clientid); if (client == NULL) @@ -2347,13 +2416,16 @@ int snd_seq_kernel_client_write_poll(int clientid, struct file *file, poll_table /*---------------------------------------------------------------------------*/ +#ifdef CONFIG_PROC_FS /* * /proc interface */ -static void snd_seq_info_dump_subscribers(snd_info_buffer_t *buffer, port_subs_info_t *group, int is_src, char *msg) +static void snd_seq_info_dump_subscribers(struct snd_info_buffer *buffer, + struct snd_seq_port_subs_info *group, + int is_src, char *msg) { struct list_head *p; - subscribers_t *s; + struct snd_seq_subscribers *s; int count = 0; down_read(&group->list_mutex); @@ -2364,9 +2436,9 @@ static void snd_seq_info_dump_subscribers(snd_info_buffer_t *buffer, port_subs_i snd_iprintf(buffer, msg); list_for_each(p, &group->list_head) { if (is_src) - s = list_entry(p, subscribers_t, src_list); + s = list_entry(p, struct snd_seq_subscribers, src_list); else - s = list_entry(p, subscribers_t, dest_list); + s = list_entry(p, struct snd_seq_subscribers, dest_list); if (count++) snd_iprintf(buffer, ", "); snd_iprintf(buffer, "%d:%d", @@ -2387,13 +2459,14 @@ static void snd_seq_info_dump_subscribers(snd_info_buffer_t *buffer, port_subs_i #define FLAG_PERM_DUPLEX(perm) ((perm) & SNDRV_SEQ_PORT_CAP_DUPLEX ? 'X' : '-') -static void snd_seq_info_dump_ports(snd_info_buffer_t *buffer, client_t *client) +static void snd_seq_info_dump_ports(struct snd_info_buffer *buffer, + struct snd_seq_client *client) { struct list_head *l; down(&client->ports_mutex); list_for_each(l, &client->ports_list_head) { - client_port_t *p = list_entry(l, client_port_t, list); + struct snd_seq_client_port *p = list_entry(l, struct snd_seq_client_port, list); snd_iprintf(buffer, " Port %3d : \"%s\" (%c%c%c%c)\n", p->addr.port, p->name, FLAG_PERM_RD(p->capability), @@ -2407,13 +2480,15 @@ static void snd_seq_info_dump_ports(snd_info_buffer_t *buffer, client_t *client) } +void snd_seq_info_pool(struct snd_info_buffer *buffer, + struct snd_seq_pool *pool, char *space); + /* exported to seq_info.c */ -void snd_seq_info_clients_read(snd_info_entry_t *entry, - snd_info_buffer_t * buffer) +void snd_seq_info_clients_read(struct snd_info_entry *entry, + struct snd_info_buffer *buffer) { - extern void snd_seq_info_pool(snd_info_buffer_t * buffer, pool_t * pool, char *space); int c; - client_t *client; + struct snd_seq_client *client; snd_iprintf(buffer, "Client info\n"); snd_iprintf(buffer, " cur clients : %d\n", client_usage.cur); @@ -2447,7 +2522,7 @@ void snd_seq_info_clients_read(snd_info_entry_t *entry, snd_seq_client_unlock(client); } } - +#endif /* CONFIG_PROC_FS */ /*---------------------------------------------------------------------------*/ @@ -2468,13 +2543,6 @@ static struct file_operations snd_seq_f_ops = .compat_ioctl = snd_seq_ioctl_compat, }; -static snd_minor_t snd_seq_reg = -{ - .comment = "sequencer", - .f_ops = &snd_seq_f_ops, -}; - - /* * register sequencer device */ @@ -2485,7 +2553,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, NULL, "seq")) < 0) { up(®ister_mutex); return err; } diff --git a/sound/core/seq/seq_clientmgr.h b/sound/core/seq/seq_clientmgr.h index 3715c36183d..450091ca153 100644 --- a/sound/core/seq/seq_clientmgr.h +++ b/sound/core/seq/seq_clientmgr.h @@ -30,24 +30,21 @@ /* client manager */ -struct _snd_seq_user_client { +struct snd_seq_user_client { struct file *file; /* file struct of client */ /* ... */ /* fifo */ - fifo_t *fifo; /* queue for incoming events */ + struct snd_seq_fifo *fifo; /* queue for incoming events */ int fifo_pool_size; }; -struct _snd_seq_kernel_client { - snd_card_t *card; - /* pointer to client functions */ - void *private_data; /* private data for client */ +struct snd_seq_kernel_client { /* ... */ }; -struct _snd_seq_client { +struct snd_seq_client { snd_seq_client_type_t type; unsigned int accept_input: 1, accept_output: 1; @@ -65,40 +62,40 @@ struct _snd_seq_client { int convert32; /* convert 32->64bit */ /* output pool */ - pool_t *pool; /* memory pool for this client */ + struct snd_seq_pool *pool; /* memory pool for this client */ union { - user_client_t user; - kernel_client_t kernel; + struct snd_seq_user_client user; + struct snd_seq_kernel_client kernel; } data; }; /* usage statistics */ -typedef struct { +struct snd_seq_usage { int cur; int peak; -} usage_t; +}; -extern int client_init_data(void); -extern int snd_sequencer_device_init(void); -extern void snd_sequencer_device_done(void); +int client_init_data(void); +int snd_sequencer_device_init(void); +void snd_sequencer_device_done(void); /* get locked pointer to client */ -extern client_t *snd_seq_client_use_ptr(int clientid); +struct snd_seq_client *snd_seq_client_use_ptr(int clientid); /* unlock pointer to client */ #define snd_seq_client_unlock(client) snd_use_lock_free(&(client)->use_lock) /* dispatch event to client(s) */ -extern int snd_seq_dispatch_event(snd_seq_event_cell_t *cell, int atomic, int hop); +int snd_seq_dispatch_event(struct snd_seq_event_cell *cell, int atomic, int hop); /* exported to other modules */ -extern int snd_seq_register_kernel_client(snd_seq_client_callback_t *callback, void *private_data); -extern int snd_seq_unregister_kernel_client(int client); -extern int snd_seq_kernel_client_enqueue(int client, snd_seq_event_t *ev, int atomic, int hop); -int snd_seq_kernel_client_enqueue_blocking(int client, snd_seq_event_t * ev, struct file *file, int atomic, int hop); +int snd_seq_kernel_client_enqueue(int client, struct snd_seq_event *ev, int atomic, int hop); +int snd_seq_kernel_client_enqueue_blocking(int client, struct snd_seq_event * ev, + struct file *file, int atomic, int hop); int snd_seq_kernel_client_write_poll(int clientid, struct file *file, poll_table *wait); -int snd_seq_client_notify_subscription(int client, int port, snd_seq_port_subscribe_t *info, int evtype); +int snd_seq_client_notify_subscription(int client, int port, + struct snd_seq_port_subscribe *info, int evtype); #endif diff --git a/sound/core/seq/seq_compat.c b/sound/core/seq/seq_compat.c index 902ad8b0c35..9628c06e4ea 100644 --- a/sound/core/seq/seq_compat.c +++ b/sound/core/seq/seq_compat.c @@ -22,8 +22,8 @@ #include <linux/compat.h> -struct sndrv_seq_port_info32 { - struct sndrv_seq_addr addr; /* client/port numbers */ +struct snd_seq_port_info32 { + struct snd_seq_addr addr; /* client/port numbers */ char name[64]; /* port name */ u32 capability; /* port capability bits */ @@ -41,11 +41,11 @@ struct sndrv_seq_port_info32 { char reserved[59]; /* for future use */ }; -static int snd_seq_call_port_info_ioctl(client_t *client, unsigned int cmd, - struct sndrv_seq_port_info32 __user *data32) +static int snd_seq_call_port_info_ioctl(struct snd_seq_client *client, unsigned int cmd, + struct snd_seq_port_info32 __user *data32) { int err = -EFAULT; - snd_seq_port_info_t *data; + struct snd_seq_port_info *data; mm_segment_t fs; data = kmalloc(sizeof(*data), GFP_KERNEL); @@ -80,16 +80,16 @@ static int snd_seq_call_port_info_ioctl(client_t *client, unsigned int cmd, */ enum { - SNDRV_SEQ_IOCTL_CREATE_PORT32 = _IOWR('S', 0x20, struct sndrv_seq_port_info32), - SNDRV_SEQ_IOCTL_DELETE_PORT32 = _IOW ('S', 0x21, struct sndrv_seq_port_info32), - SNDRV_SEQ_IOCTL_GET_PORT_INFO32 = _IOWR('S', 0x22, struct sndrv_seq_port_info32), - SNDRV_SEQ_IOCTL_SET_PORT_INFO32 = _IOW ('S', 0x23, struct sndrv_seq_port_info32), - SNDRV_SEQ_IOCTL_QUERY_NEXT_PORT32 = _IOWR('S', 0x52, struct sndrv_seq_port_info32), + SNDRV_SEQ_IOCTL_CREATE_PORT32 = _IOWR('S', 0x20, struct snd_seq_port_info32), + SNDRV_SEQ_IOCTL_DELETE_PORT32 = _IOW ('S', 0x21, struct snd_seq_port_info32), + SNDRV_SEQ_IOCTL_GET_PORT_INFO32 = _IOWR('S', 0x22, struct snd_seq_port_info32), + SNDRV_SEQ_IOCTL_SET_PORT_INFO32 = _IOW ('S', 0x23, struct snd_seq_port_info32), + SNDRV_SEQ_IOCTL_QUERY_NEXT_PORT32 = _IOWR('S', 0x52, struct snd_seq_port_info32), }; static long snd_seq_ioctl_compat(struct file *file, unsigned int cmd, unsigned long arg) { - client_t *client = (client_t *) file->private_data; + struct snd_seq_client *client = file->private_data; void __user *argp = compat_ptr(arg); snd_assert(client != NULL, return -ENXIO); diff --git a/sound/core/seq/seq_device.c b/sound/core/seq/seq_device.c index 252b5273100..9ece443fba5 100644 --- a/sound/core/seq/seq_device.c +++ b/sound/core/seq/seq_device.c @@ -50,11 +50,6 @@ MODULE_AUTHOR("Takashi Iwai <tiwai@suse.de>"); MODULE_DESCRIPTION("ALSA sequencer device management"); MODULE_LICENSE("GPL"); -/* - * driver list - */ -typedef struct ops_list ops_list_t; - /* driver state */ #define DRIVER_EMPTY 0 #define DRIVER_LOADED (1<<0) @@ -68,7 +63,7 @@ struct ops_list { int argsize; /* argument size */ /* operators */ - snd_seq_dev_ops_t ops; + struct snd_seq_dev_ops ops; /* registred devices */ struct list_head dev_list; /* list of devices */ @@ -83,35 +78,39 @@ struct ops_list { static LIST_HEAD(opslist); static int num_ops; static DECLARE_MUTEX(ops_mutex); -static snd_info_entry_t *info_entry = NULL; +#ifdef CONFIG_PROC_FS +static struct snd_info_entry *info_entry = NULL; +#endif /* * prototypes */ -static int snd_seq_device_free(snd_seq_device_t *dev); -static int snd_seq_device_dev_free(snd_device_t *device); -static int snd_seq_device_dev_register(snd_device_t *device); -static int snd_seq_device_dev_disconnect(snd_device_t *device); -static int snd_seq_device_dev_unregister(snd_device_t *device); - -static int init_device(snd_seq_device_t *dev, ops_list_t *ops); -static int free_device(snd_seq_device_t *dev, ops_list_t *ops); -static ops_list_t *find_driver(char *id, int create_if_empty); -static ops_list_t *create_driver(char *id); -static void unlock_driver(ops_list_t *ops); +static int snd_seq_device_free(struct snd_seq_device *dev); +static int snd_seq_device_dev_free(struct snd_device *device); +static int snd_seq_device_dev_register(struct snd_device *device); +static int snd_seq_device_dev_disconnect(struct snd_device *device); +static int snd_seq_device_dev_unregister(struct snd_device *device); + +static int init_device(struct snd_seq_device *dev, struct ops_list *ops); +static int free_device(struct snd_seq_device *dev, struct ops_list *ops); +static struct ops_list *find_driver(char *id, int create_if_empty); +static struct ops_list *create_driver(char *id); +static void unlock_driver(struct ops_list *ops); static void remove_drivers(void); /* * show all drivers and their status */ -static void snd_seq_device_info(snd_info_entry_t *entry, snd_info_buffer_t * buffer) +#ifdef CONFIG_PROC_FS +static void snd_seq_device_info(struct snd_info_entry *entry, + struct snd_info_buffer *buffer) { struct list_head *head; down(&ops_mutex); list_for_each(head, &opslist) { - ops_list_t *ops = list_entry(head, ops_list_t, list); + struct ops_list *ops = list_entry(head, struct ops_list, list); snd_iprintf(buffer, "snd-%s%s%s%s,%d\n", ops->id, ops->driver & DRIVER_LOADED ? ",loaded" : (ops->driver == DRIVER_EMPTY ? ",empty" : ""), @@ -121,6 +120,7 @@ static void snd_seq_device_info(snd_info_entry_t *entry, snd_info_buffer_t * buf } up(&ops_mutex); } +#endif /* * load all registered drivers (called from seq_clientmgr.c) @@ -156,7 +156,7 @@ void snd_seq_device_load_drivers(void) down(&ops_mutex); list_for_each(head, &opslist) { - ops_list_t *ops = list_entry(head, ops_list_t, list); + struct ops_list *ops = list_entry(head, struct ops_list, list); if (! (ops->driver & DRIVER_LOADED) && ! (ops->driver & DRIVER_REQUESTED)) { ops->used++; @@ -178,13 +178,13 @@ void snd_seq_device_load_drivers(void) * id = id of driver * result = return pointer (NULL allowed if unnecessary) */ -int snd_seq_device_new(snd_card_t *card, int device, char *id, int argsize, - snd_seq_device_t **result) +int snd_seq_device_new(struct snd_card *card, int device, char *id, int argsize, + struct snd_seq_device **result) { - snd_seq_device_t *dev; - ops_list_t *ops; + struct snd_seq_device *dev; + struct ops_list *ops; int err; - static snd_device_ops_t dops = { + static struct snd_device_ops dops = { .dev_free = snd_seq_device_dev_free, .dev_register = snd_seq_device_dev_register, .dev_disconnect = snd_seq_device_dev_disconnect, @@ -235,9 +235,9 @@ int snd_seq_device_new(snd_card_t *card, int device, char *id, int argsize, /* * free the existing device */ -static int snd_seq_device_free(snd_seq_device_t *dev) +static int snd_seq_device_free(struct snd_seq_device *dev) { - ops_list_t *ops; + struct ops_list *ops; snd_assert(dev != NULL, return -EINVAL); @@ -261,19 +261,19 @@ static int snd_seq_device_free(snd_seq_device_t *dev) return 0; } -static int snd_seq_device_dev_free(snd_device_t *device) +static int snd_seq_device_dev_free(struct snd_device *device) { - snd_seq_device_t *dev = device->device_data; + struct snd_seq_device *dev = device->device_data; return snd_seq_device_free(dev); } /* * register the device */ -static int snd_seq_device_dev_register(snd_device_t *device) +static int snd_seq_device_dev_register(struct snd_device *device) { - snd_seq_device_t *dev = device->device_data; - ops_list_t *ops; + struct snd_seq_device *dev = device->device_data; + struct ops_list *ops; ops = find_driver(dev->id, 0); if (ops == NULL) @@ -292,10 +292,10 @@ static int snd_seq_device_dev_register(snd_device_t *device) /* * disconnect the device */ -static int snd_seq_device_dev_disconnect(snd_device_t *device) +static int snd_seq_device_dev_disconnect(struct snd_device *device) { - snd_seq_device_t *dev = device->device_data; - ops_list_t *ops; + struct snd_seq_device *dev = device->device_data; + struct ops_list *ops; ops = find_driver(dev->id, 0); if (ops == NULL) @@ -310,9 +310,9 @@ static int snd_seq_device_dev_disconnect(snd_device_t *device) /* * unregister the existing device */ -static int snd_seq_device_dev_unregister(snd_device_t *device) +static int snd_seq_device_dev_unregister(struct snd_device *device) { - snd_seq_device_t *dev = device->device_data; + struct snd_seq_device *dev = device->device_data; return snd_seq_device_free(dev); } @@ -321,10 +321,11 @@ static int snd_seq_device_dev_unregister(snd_device_t *device) * id = driver id * entry = driver operators - duplicated to each instance */ -int snd_seq_device_register_driver(char *id, snd_seq_dev_ops_t *entry, int argsize) +int snd_seq_device_register_driver(char *id, struct snd_seq_dev_ops *entry, + int argsize) { struct list_head *head; - ops_list_t *ops; + struct ops_list *ops; if (id == NULL || entry == NULL || entry->init_device == NULL || entry->free_device == NULL) @@ -351,7 +352,7 @@ int snd_seq_device_register_driver(char *id, snd_seq_dev_ops_t *entry, int argsi /* initialize existing devices if necessary */ list_for_each(head, &ops->dev_list) { - snd_seq_device_t *dev = list_entry(head, snd_seq_device_t, list); + struct snd_seq_device *dev = list_entry(head, struct snd_seq_device, list); init_device(dev, ops); } up(&ops->reg_mutex); @@ -366,9 +367,9 @@ int snd_seq_device_register_driver(char *id, snd_seq_dev_ops_t *entry, int argsi /* * create driver record */ -static ops_list_t * create_driver(char *id) +static struct ops_list * create_driver(char *id) { - ops_list_t *ops; + struct ops_list *ops; ops = kmalloc(sizeof(*ops), GFP_KERNEL); if (ops == NULL) @@ -399,14 +400,15 @@ static ops_list_t * create_driver(char *id) int snd_seq_device_unregister_driver(char *id) { struct list_head *head; - ops_list_t *ops; + struct ops_list *ops; ops = find_driver(id, 0); if (ops == NULL) return -ENXIO; if (! (ops->driver & DRIVER_LOADED) || (ops->driver & DRIVER_LOCKED)) { - snd_printk(KERN_ERR "driver_unregister: cannot unload driver '%s': status=%x\n", id, ops->driver); + snd_printk(KERN_ERR "driver_unregister: cannot unload driver '%s': status=%x\n", + id, ops->driver); unlock_driver(ops); return -EBUSY; } @@ -415,13 +417,14 @@ int snd_seq_device_unregister_driver(char *id) down(&ops->reg_mutex); ops->driver |= DRIVER_LOCKED; /* do not remove this driver recursively */ list_for_each(head, &ops->dev_list) { - snd_seq_device_t *dev = list_entry(head, snd_seq_device_t, list); + struct snd_seq_device *dev = list_entry(head, struct snd_seq_device, list); free_device(dev, ops); } ops->driver = 0; if (ops->num_init_devices > 0) - snd_printk(KERN_ERR "free_driver: init_devices > 0!! (%d)\n", ops->num_init_devices); + snd_printk(KERN_ERR "free_driver: init_devices > 0!! (%d)\n", + ops->num_init_devices); up(&ops->reg_mutex); unlock_driver(ops); @@ -443,7 +446,7 @@ static void remove_drivers(void) down(&ops_mutex); head = opslist.next; while (head != &opslist) { - ops_list_t *ops = list_entry(head, ops_list_t, list); + struct ops_list *ops = list_entry(head, struct ops_list, list); if (! (ops->driver & DRIVER_LOADED) && ops->used == 0 && ops->num_devices == 0) { head = head->next; @@ -459,21 +462,23 @@ static void remove_drivers(void) /* * initialize the device - call init_device operator */ -static int init_device(snd_seq_device_t *dev, ops_list_t *ops) +static int init_device(struct snd_seq_device *dev, struct ops_list *ops) { if (! (ops->driver & DRIVER_LOADED)) return 0; /* driver is not loaded yet */ if (dev->status != SNDRV_SEQ_DEVICE_FREE) return 0; /* already initialized */ if (ops->argsize != dev->argsize) { - snd_printk(KERN_ERR "incompatible device '%s' for plug-in '%s' (%d %d)\n", dev->name, ops->id, ops->argsize, dev->argsize); + snd_printk(KERN_ERR "incompatible device '%s' for plug-in '%s' (%d %d)\n", + dev->name, ops->id, ops->argsize, dev->argsize); return -EINVAL; } if (ops->ops.init_device(dev) >= 0) { dev->status = SNDRV_SEQ_DEVICE_REGISTERED; ops->num_init_devices++; } else { - snd_printk(KERN_ERR "init_device failed: %s: %s\n", dev->name, dev->id); + snd_printk(KERN_ERR "init_device failed: %s: %s\n", + dev->name, dev->id); } return 0; @@ -482,7 +487,7 @@ static int init_device(snd_seq_device_t *dev, ops_list_t *ops) /* * release the device - call free_device operator */ -static int free_device(snd_seq_device_t *dev, ops_list_t *ops) +static int free_device(struct snd_seq_device *dev, struct ops_list *ops) { int result; @@ -491,7 +496,8 @@ static int free_device(snd_seq_device_t *dev, ops_list_t *ops) if (dev->status != SNDRV_SEQ_DEVICE_REGISTERED) return 0; /* not registered */ if (ops->argsize != dev->argsize) { - snd_printk(KERN_ERR "incompatible device '%s' for plug-in '%s' (%d %d)\n", dev->name, ops->id, ops->argsize, dev->argsize); + snd_printk(KERN_ERR "incompatible device '%s' for plug-in '%s' (%d %d)\n", + dev->name, ops->id, ops->argsize, dev->argsize); return -EINVAL; } if ((result = ops->ops.free_device(dev)) >= 0 || result == -ENXIO) { @@ -499,7 +505,8 @@ static int free_device(snd_seq_device_t *dev, ops_list_t *ops) dev->driver_data = NULL; ops->num_init_devices--; } else { - snd_printk(KERN_ERR "free_device failed: %s: %s\n", dev->name, dev->id); + snd_printk(KERN_ERR "free_device failed: %s: %s\n", + dev->name, dev->id); } return 0; @@ -508,13 +515,13 @@ static int free_device(snd_seq_device_t *dev, ops_list_t *ops) /* * find the matching driver with given id */ -static ops_list_t * find_driver(char *id, int create_if_empty) +static struct ops_list * find_driver(char *id, int create_if_empty) { struct list_head *head; down(&ops_mutex); list_for_each(head, &opslist) { - ops_list_t *ops = list_entry(head, ops_list_t, list); + struct ops_list *ops = list_entry(head, struct ops_list, list); if (strcmp(ops->id, id) == 0) { ops->used++; up(&ops_mutex); @@ -527,7 +534,7 @@ static ops_list_t * find_driver(char *id, int create_if_empty) return NULL; } -static void unlock_driver(ops_list_t *ops) +static void unlock_driver(struct ops_list *ops) { down(&ops_mutex); ops->used--; @@ -541,7 +548,9 @@ static void unlock_driver(ops_list_t *ops) static int __init alsa_seq_device_init(void) { - info_entry = snd_info_create_module_entry(THIS_MODULE, "drivers", snd_seq_root); +#ifdef CONFIG_PROC_FS + info_entry = snd_info_create_module_entry(THIS_MODULE, "drivers", + snd_seq_root); if (info_entry == NULL) return -ENOMEM; info_entry->content = SNDRV_INFO_CONTENT_TEXT; @@ -551,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_dummy.c b/sound/core/seq/seq_dummy.c index 5dd0e6a19e5..2a283a59ea4 100644 --- a/sound/core/seq/seq_dummy.c +++ b/sound/core/seq/seq_dummy.c @@ -73,12 +73,12 @@ MODULE_PARM_DESC(ports, "number of ports to be created"); module_param(duplex, bool, 0444); MODULE_PARM_DESC(duplex, "create DUPLEX ports"); -typedef struct snd_seq_dummy_port { +struct snd_seq_dummy_port { int client; int port; int duplex; int connect; -} snd_seq_dummy_port_t; +}; static int my_client = -1; @@ -88,11 +88,11 @@ static int my_client = -1; * Note: this callback is called only after all subscribers are removed. */ static int -dummy_unuse(void *private_data, snd_seq_port_subscribe_t *info) +dummy_unuse(void *private_data, struct snd_seq_port_subscribe *info) { - snd_seq_dummy_port_t *p; + struct snd_seq_dummy_port *p; int i; - snd_seq_event_t ev; + struct snd_seq_event ev; p = private_data; memset(&ev, 0, sizeof(ev)); @@ -116,10 +116,11 @@ dummy_unuse(void *private_data, snd_seq_port_subscribe_t *info) * event input callback - just redirect events to subscribers */ static int -dummy_input(snd_seq_event_t *ev, int direct, void *private_data, int atomic, int hop) +dummy_input(struct snd_seq_event *ev, int direct, void *private_data, + int atomic, int hop) { - snd_seq_dummy_port_t *p; - snd_seq_event_t tmpev; + struct snd_seq_dummy_port *p; + struct snd_seq_event tmpev; p = private_data; if (ev->source.client == SNDRV_SEQ_CLIENT_SYSTEM || @@ -146,12 +147,12 @@ dummy_free(void *private_data) /* * create a port */ -static snd_seq_dummy_port_t __init * +static struct snd_seq_dummy_port __init * create_port(int idx, int type) { - snd_seq_port_info_t pinfo; - snd_seq_port_callback_t pcb; - snd_seq_dummy_port_t *rec; + struct snd_seq_port_info pinfo; + struct snd_seq_port_callback pcb; + struct snd_seq_dummy_port *rec; if ((rec = kzalloc(sizeof(*rec), GFP_KERNEL)) == NULL) return NULL; @@ -192,9 +193,7 @@ create_port(int idx, int type) static int __init register_client(void) { - snd_seq_client_callback_t cb; - snd_seq_client_info_t cinfo; - snd_seq_dummy_port_t *rec1, *rec2; + struct snd_seq_dummy_port *rec1, *rec2; int i; if (ports < 1) { @@ -203,20 +202,11 @@ register_client(void) } /* create client */ - memset(&cb, 0, sizeof(cb)); - cb.allow_input = 1; - cb.allow_output = 1; - my_client = snd_seq_create_kernel_client(NULL, SNDRV_SEQ_CLIENT_DUMMY, &cb); + my_client = snd_seq_create_kernel_client(NULL, SNDRV_SEQ_CLIENT_DUMMY, + "Midi Through"); if (my_client < 0) return my_client; - /* set client name */ - memset(&cinfo, 0, sizeof(cinfo)); - cinfo.client = my_client; - cinfo.type = KERNEL_CLIENT; - strcpy(cinfo.name, "Midi Through"); - snd_seq_kernel_client_ctl(my_client, SNDRV_SEQ_IOCTL_SET_CLIENT_INFO, &cinfo); - /* create ports */ for (i = 0; i < ports; i++) { rec1 = create_port(i, 0); diff --git a/sound/core/seq/seq_fifo.c b/sound/core/seq/seq_fifo.c index 4767cfdc361..6b055aed7a4 100644 --- a/sound/core/seq/seq_fifo.c +++ b/sound/core/seq/seq_fifo.c @@ -29,9 +29,9 @@ /* FIFO */ /* create new fifo */ -fifo_t *snd_seq_fifo_new(int poolsize) +struct snd_seq_fifo *snd_seq_fifo_new(int poolsize) { - fifo_t *f; + struct snd_seq_fifo *f; f = kzalloc(sizeof(*f), GFP_KERNEL); if (f == NULL) { @@ -62,9 +62,9 @@ fifo_t *snd_seq_fifo_new(int poolsize) return f; } -void snd_seq_fifo_delete(fifo_t **fifo) +void snd_seq_fifo_delete(struct snd_seq_fifo **fifo) { - fifo_t *f; + struct snd_seq_fifo *f; snd_assert(fifo != NULL, return); f = *fifo; @@ -88,12 +88,12 @@ void snd_seq_fifo_delete(fifo_t **fifo) kfree(f); } -static snd_seq_event_cell_t *fifo_cell_out(fifo_t *f); +static struct snd_seq_event_cell *fifo_cell_out(struct snd_seq_fifo *f); /* clear queue */ -void snd_seq_fifo_clear(fifo_t *f) +void snd_seq_fifo_clear(struct snd_seq_fifo *f) { - snd_seq_event_cell_t *cell; + struct snd_seq_event_cell *cell; unsigned long flags; /* clear overflow flag */ @@ -110,9 +110,10 @@ void snd_seq_fifo_clear(fifo_t *f) /* enqueue event to fifo */ -int snd_seq_fifo_event_in(fifo_t *f, snd_seq_event_t *event) +int snd_seq_fifo_event_in(struct snd_seq_fifo *f, + struct snd_seq_event *event) { - snd_seq_event_cell_t *cell; + struct snd_seq_event_cell *cell; unsigned long flags; int err; @@ -148,9 +149,9 @@ int snd_seq_fifo_event_in(fifo_t *f, snd_seq_event_t *event) } /* dequeue cell from fifo */ -static snd_seq_event_cell_t *fifo_cell_out(fifo_t *f) +static struct snd_seq_event_cell *fifo_cell_out(struct snd_seq_fifo *f) { - snd_seq_event_cell_t *cell; + struct snd_seq_event_cell *cell; if ((cell = f->head) != NULL) { f->head = cell->next; @@ -167,9 +168,10 @@ static snd_seq_event_cell_t *fifo_cell_out(fifo_t *f) } /* dequeue cell from fifo and copy on user space */ -int snd_seq_fifo_cell_out(fifo_t *f, snd_seq_event_cell_t **cellp, int nonblock) +int snd_seq_fifo_cell_out(struct snd_seq_fifo *f, + struct snd_seq_event_cell **cellp, int nonblock) { - snd_seq_event_cell_t *cell; + struct snd_seq_event_cell *cell; unsigned long flags; wait_queue_t wait; @@ -202,7 +204,8 @@ int snd_seq_fifo_cell_out(fifo_t *f, snd_seq_event_cell_t **cellp, int nonblock) } -void snd_seq_fifo_cell_putback(fifo_t *f, snd_seq_event_cell_t *cell) +void snd_seq_fifo_cell_putback(struct snd_seq_fifo *f, + struct snd_seq_event_cell *cell) { unsigned long flags; @@ -217,18 +220,19 @@ void snd_seq_fifo_cell_putback(fifo_t *f, snd_seq_event_cell_t *cell) /* polling; return non-zero if queue is available */ -int snd_seq_fifo_poll_wait(fifo_t *f, struct file *file, poll_table *wait) +int snd_seq_fifo_poll_wait(struct snd_seq_fifo *f, struct file *file, + poll_table *wait) { poll_wait(file, &f->input_sleep, wait); return (f->cells > 0); } /* change the size of pool; all old events are removed */ -int snd_seq_fifo_resize(fifo_t *f, int poolsize) +int snd_seq_fifo_resize(struct snd_seq_fifo *f, int poolsize) { unsigned long flags; - pool_t *newpool, *oldpool; - snd_seq_event_cell_t *cell, *next, *oldhead; + struct snd_seq_pool *newpool, *oldpool; + struct snd_seq_event_cell *cell, *next, *oldhead; snd_assert(f != NULL && f->pool != NULL, return -EINVAL); diff --git a/sound/core/seq/seq_fifo.h b/sound/core/seq/seq_fifo.h index d677c261b0a..062c446e786 100644 --- a/sound/core/seq/seq_fifo.h +++ b/sound/core/seq/seq_fifo.h @@ -27,46 +27,46 @@ /* === FIFO === */ -typedef struct { - pool_t *pool; /* FIFO pool */ - snd_seq_event_cell_t* head; /* pointer to head of fifo */ - snd_seq_event_cell_t* tail; /* pointer to tail of fifo */ +struct snd_seq_fifo { + struct snd_seq_pool *pool; /* FIFO pool */ + struct snd_seq_event_cell *head; /* pointer to head of fifo */ + struct snd_seq_event_cell *tail; /* pointer to tail of fifo */ int cells; spinlock_t lock; snd_use_lock_t use_lock; wait_queue_head_t input_sleep; atomic_t overflow; -} fifo_t; +}; /* create new fifo (constructor) */ -extern fifo_t *snd_seq_fifo_new(int poolsize); +struct snd_seq_fifo *snd_seq_fifo_new(int poolsize); /* delete fifo (destructor) */ -extern void snd_seq_fifo_delete(fifo_t **f); +void snd_seq_fifo_delete(struct snd_seq_fifo **f); /* enqueue event to fifo */ -extern int snd_seq_fifo_event_in(fifo_t *f, snd_seq_event_t *event); +int snd_seq_fifo_event_in(struct snd_seq_fifo *f, struct snd_seq_event *event); /* lock fifo from release */ #define snd_seq_fifo_lock(fifo) snd_use_lock_use(&(fifo)->use_lock) #define snd_seq_fifo_unlock(fifo) snd_use_lock_free(&(fifo)->use_lock) /* get a cell from fifo - fifo should be locked */ -int snd_seq_fifo_cell_out(fifo_t *f, snd_seq_event_cell_t **cellp, int nonblock); +int snd_seq_fifo_cell_out(struct snd_seq_fifo *f, struct snd_seq_event_cell **cellp, int nonblock); /* free dequeued cell - fifo should be locked */ -extern void snd_seq_fifo_cell_putback(fifo_t *f, snd_seq_event_cell_t *cell); +void snd_seq_fifo_cell_putback(struct snd_seq_fifo *f, struct snd_seq_event_cell *cell); /* clean up queue */ -extern void snd_seq_fifo_clear(fifo_t *f); +void snd_seq_fifo_clear(struct snd_seq_fifo *f); /* polling */ -extern int snd_seq_fifo_poll_wait(fifo_t *f, struct file *file, poll_table *wait); +int snd_seq_fifo_poll_wait(struct snd_seq_fifo *f, struct file *file, poll_table *wait); /* resize pool in fifo */ -int snd_seq_fifo_resize(fifo_t *f, int poolsize); +int snd_seq_fifo_resize(struct snd_seq_fifo *f, int poolsize); #endif diff --git a/sound/core/seq/seq_info.c b/sound/core/seq/seq_info.c index b50b695c41c..acce21afdaa 100644 --- a/sound/core/seq/seq_info.c +++ b/sound/core/seq/seq_info.c @@ -27,16 +27,17 @@ #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; -static snd_info_entry_t *queues_entry; -static snd_info_entry_t *clients_entry; -static snd_info_entry_t *timer_entry; - -static snd_info_entry_t * __init -create_info_entry(char *name, int size, void (*read)(snd_info_entry_t *, snd_info_buffer_t *)) +static struct snd_info_entry * __init +create_info_entry(char *name, int size, void (*read)(struct snd_info_entry *, + struct snd_info_buffer *)) { - snd_info_entry_t *entry; + struct snd_info_entry *entry; entry = snd_info_create_module_entry(THIS_MODULE, name, snd_seq_root); if (entry == NULL) @@ -51,7 +52,6 @@ create_info_entry(char *name, int size, void (*read)(snd_info_entry_t *, snd_inf return entry; } - /* create all our /proc entries */ int __init snd_seq_info_init(void) { @@ -65,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 efd099a858e..4892a7f35c0 100644 --- a/sound/core/seq/seq_info.h +++ b/sound/core/seq/seq_info.h @@ -24,13 +24,17 @@ #include <sound/info.h> #include <sound/seq_kernel.h> -void snd_seq_info_clients_read(snd_info_entry_t *entry, snd_info_buffer_t * buffer); -void snd_seq_info_timer_read(snd_info_entry_t *entry, snd_info_buffer_t * buffer); -void snd_seq_info_queues_read(snd_info_entry_t *entry, snd_info_buffer_t * buffer); +void snd_seq_info_clients_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer); +void snd_seq_info_timer_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer); +void snd_seq_info_queues_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer); +#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_instr.c b/sound/core/seq/seq_instr.c index 1d525b13ebb..48745206396 100644 --- a/sound/core/seq/seq_instr.c +++ b/sound/core/seq/seq_instr.c @@ -31,7 +31,7 @@ MODULE_DESCRIPTION("Advanced Linux Sound Architecture sequencer instrument libra MODULE_LICENSE("GPL"); -static void snd_instr_lock_ops(snd_seq_kinstr_list_t *list) +static void snd_instr_lock_ops(struct snd_seq_kinstr_list *list) { if (!(list->flags & SNDRV_SEQ_INSTR_FLG_DIRECT)) { spin_lock_irqsave(&list->ops_lock, list->ops_flags); @@ -40,7 +40,7 @@ static void snd_instr_lock_ops(snd_seq_kinstr_list_t *list) } } -static void snd_instr_unlock_ops(snd_seq_kinstr_list_t *list) +static void snd_instr_unlock_ops(struct snd_seq_kinstr_list *list) { if (!(list->flags & SNDRV_SEQ_INSTR_FLG_DIRECT)) { spin_unlock_irqrestore(&list->ops_lock, list->ops_flags); @@ -49,18 +49,18 @@ static void snd_instr_unlock_ops(snd_seq_kinstr_list_t *list) } } -static snd_seq_kinstr_t *snd_seq_instr_new(int add_len, int atomic) +static struct snd_seq_kinstr *snd_seq_instr_new(int add_len, int atomic) { - snd_seq_kinstr_t *instr; + struct snd_seq_kinstr *instr; - instr = kzalloc(sizeof(snd_seq_kinstr_t) + add_len, atomic ? GFP_ATOMIC : GFP_KERNEL); + instr = kzalloc(sizeof(struct snd_seq_kinstr) + add_len, atomic ? GFP_ATOMIC : GFP_KERNEL); if (instr == NULL) return NULL; instr->add_len = add_len; return instr; } -static int snd_seq_instr_free(snd_seq_kinstr_t *instr, int atomic) +static int snd_seq_instr_free(struct snd_seq_kinstr *instr, int atomic) { int result = 0; @@ -73,11 +73,11 @@ static int snd_seq_instr_free(snd_seq_kinstr_t *instr, int atomic) return result; } -snd_seq_kinstr_list_t *snd_seq_instr_list_new(void) +struct snd_seq_kinstr_list *snd_seq_instr_list_new(void) { - snd_seq_kinstr_list_t *list; + struct snd_seq_kinstr_list *list; - list = kzalloc(sizeof(snd_seq_kinstr_list_t), GFP_KERNEL); + list = kzalloc(sizeof(struct snd_seq_kinstr_list), GFP_KERNEL); if (list == NULL) return NULL; spin_lock_init(&list->lock); @@ -87,11 +87,11 @@ snd_seq_kinstr_list_t *snd_seq_instr_list_new(void) return list; } -void snd_seq_instr_list_free(snd_seq_kinstr_list_t **list_ptr) +void snd_seq_instr_list_free(struct snd_seq_kinstr_list **list_ptr) { - snd_seq_kinstr_list_t *list; - snd_seq_kinstr_t *instr; - snd_seq_kcluster_t *cluster; + struct snd_seq_kinstr_list *list; + struct snd_seq_kinstr *instr; + struct snd_seq_kcluster *cluster; int idx; unsigned long flags; @@ -125,8 +125,8 @@ void snd_seq_instr_list_free(snd_seq_kinstr_list_t **list_ptr) kfree(list); } -static int instr_free_compare(snd_seq_kinstr_t *instr, - snd_seq_instr_header_t *ifree, +static int instr_free_compare(struct snd_seq_kinstr *instr, + struct snd_seq_instr_header *ifree, unsigned int client) { switch (ifree->cmd) { @@ -160,12 +160,12 @@ static int instr_free_compare(snd_seq_kinstr_t *instr, return 1; } -int snd_seq_instr_list_free_cond(snd_seq_kinstr_list_t *list, - snd_seq_instr_header_t *ifree, +int snd_seq_instr_list_free_cond(struct snd_seq_kinstr_list *list, + struct snd_seq_instr_header *ifree, int client, int atomic) { - snd_seq_kinstr_t *instr, *prev, *next, *flist; + struct snd_seq_kinstr *instr, *prev, *next, *flist; int idx; unsigned long flags; @@ -209,7 +209,7 @@ int snd_seq_instr_list_free_cond(snd_seq_kinstr_list_t *list, return 0; } -static int compute_hash_instr_key(snd_seq_instr_t *instr) +static int compute_hash_instr_key(struct snd_seq_instr *instr) { int result; @@ -233,7 +233,7 @@ static int compute_hash_cluster_key(snd_seq_instr_cluster_t cluster) } #endif -static int compare_instr(snd_seq_instr_t *i1, snd_seq_instr_t *i2, int exact) +static int compare_instr(struct snd_seq_instr *i1, struct snd_seq_instr *i2, int exact) { if (exact) { if (i1->cluster != i2->cluster || @@ -262,14 +262,14 @@ static int compare_instr(snd_seq_instr_t *i1, snd_seq_instr_t *i2, int exact) } } -snd_seq_kinstr_t *snd_seq_instr_find(snd_seq_kinstr_list_t *list, - snd_seq_instr_t *instr, - int exact, - int follow_alias) +struct snd_seq_kinstr *snd_seq_instr_find(struct snd_seq_kinstr_list *list, + struct snd_seq_instr *instr, + int exact, + int follow_alias) { unsigned long flags; int depth = 0; - snd_seq_kinstr_t *result; + struct snd_seq_kinstr *result; if (list == NULL || instr == NULL) return NULL; @@ -279,7 +279,7 @@ snd_seq_kinstr_t *snd_seq_instr_find(snd_seq_kinstr_list_t *list, while (result) { if (!compare_instr(&result->instr, instr, exact)) { if (follow_alias && (result->type == SNDRV_SEQ_INSTR_ATYPE_ALIAS)) { - instr = (snd_seq_instr_t *)KINSTR_DATA(result); + instr = (struct snd_seq_instr *)KINSTR_DATA(result); if (++depth > 10) goto __not_found; goto __again; @@ -295,8 +295,8 @@ snd_seq_kinstr_t *snd_seq_instr_find(snd_seq_kinstr_list_t *list, return NULL; } -void snd_seq_instr_free_use(snd_seq_kinstr_list_t *list, - snd_seq_kinstr_t *instr) +void snd_seq_instr_free_use(struct snd_seq_kinstr_list *list, + struct snd_seq_kinstr *instr) { unsigned long flags; @@ -311,7 +311,8 @@ void snd_seq_instr_free_use(snd_seq_kinstr_list_t *list, spin_unlock_irqrestore(&list->lock, flags); } -static snd_seq_kinstr_ops_t *instr_ops(snd_seq_kinstr_ops_t *ops, char *instr_type) +static struct snd_seq_kinstr_ops *instr_ops(struct snd_seq_kinstr_ops *ops, + char *instr_type) { while (ops) { if (!strcmp(ops->instr_type, instr_type)) @@ -321,11 +322,11 @@ static snd_seq_kinstr_ops_t *instr_ops(snd_seq_kinstr_ops_t *ops, char *instr_ty return NULL; } -static int instr_result(snd_seq_event_t *ev, +static int instr_result(struct snd_seq_event *ev, int type, int result, int atomic) { - snd_seq_event_t sev; + struct snd_seq_event sev; memset(&sev, 0, sizeof(sev)); sev.type = SNDRV_SEQ_EVENT_RESULT; @@ -345,9 +346,9 @@ static int instr_result(snd_seq_event_t *ev, return snd_seq_kernel_client_dispatch(sev.source.client, &sev, atomic, 0); } -static int instr_begin(snd_seq_kinstr_ops_t *ops, - snd_seq_kinstr_list_t *list, - snd_seq_event_t *ev, +static int instr_begin(struct snd_seq_kinstr_ops *ops, + struct snd_seq_kinstr_list *list, + struct snd_seq_event *ev, int atomic, int hop) { unsigned long flags; @@ -362,9 +363,9 @@ static int instr_begin(snd_seq_kinstr_ops_t *ops, return instr_result(ev, SNDRV_SEQ_EVENT_INSTR_BEGIN, 0, atomic); } -static int instr_end(snd_seq_kinstr_ops_t *ops, - snd_seq_kinstr_list_t *list, - snd_seq_event_t *ev, +static int instr_end(struct snd_seq_kinstr_ops *ops, + struct snd_seq_kinstr_list *list, + struct snd_seq_event *ev, int atomic, int hop) { unsigned long flags; @@ -380,54 +381,55 @@ static int instr_end(snd_seq_kinstr_ops_t *ops, return instr_result(ev, SNDRV_SEQ_EVENT_INSTR_END, -EINVAL, atomic); } -static int instr_info(snd_seq_kinstr_ops_t *ops, - snd_seq_kinstr_list_t *list, - snd_seq_event_t *ev, +static int instr_info(struct snd_seq_kinstr_ops *ops, + struct snd_seq_kinstr_list *list, + struct snd_seq_event *ev, int atomic, int hop) { return -ENXIO; } -static int instr_format_info(snd_seq_kinstr_ops_t *ops, - snd_seq_kinstr_list_t *list, - snd_seq_event_t *ev, +static int instr_format_info(struct snd_seq_kinstr_ops *ops, + struct snd_seq_kinstr_list *list, + struct snd_seq_event *ev, int atomic, int hop) { return -ENXIO; } -static int instr_reset(snd_seq_kinstr_ops_t *ops, - snd_seq_kinstr_list_t *list, - snd_seq_event_t *ev, +static int instr_reset(struct snd_seq_kinstr_ops *ops, + struct snd_seq_kinstr_list *list, + struct snd_seq_event *ev, int atomic, int hop) { return -ENXIO; } -static int instr_status(snd_seq_kinstr_ops_t *ops, - snd_seq_kinstr_list_t *list, - snd_seq_event_t *ev, +static int instr_status(struct snd_seq_kinstr_ops *ops, + struct snd_seq_kinstr_list *list, + struct snd_seq_event *ev, int atomic, int hop) { return -ENXIO; } -static int instr_put(snd_seq_kinstr_ops_t *ops, - snd_seq_kinstr_list_t *list, - snd_seq_event_t *ev, +static int instr_put(struct snd_seq_kinstr_ops *ops, + struct snd_seq_kinstr_list *list, + struct snd_seq_event *ev, int atomic, int hop) { unsigned long flags; - snd_seq_instr_header_t put; - snd_seq_kinstr_t *instr; + struct snd_seq_instr_header put; + struct snd_seq_kinstr *instr; int result = -EINVAL, len, key; if ((ev->flags & SNDRV_SEQ_EVENT_LENGTH_MASK) != SNDRV_SEQ_EVENT_LENGTH_VARUSR) goto __return; - if (ev->data.ext.len < sizeof(snd_seq_instr_header_t)) + if (ev->data.ext.len < sizeof(struct snd_seq_instr_header)) goto __return; - if (copy_from_user(&put, (void __user *)ev->data.ext.ptr, sizeof(snd_seq_instr_header_t))) { + if (copy_from_user(&put, (void __user *)ev->data.ext.ptr, + sizeof(struct snd_seq_instr_header))) { result = -EFAULT; goto __return; } @@ -449,7 +451,7 @@ static int instr_put(snd_seq_kinstr_ops_t *ops, } len = ops->add_len; if (put.data.type == SNDRV_SEQ_INSTR_ATYPE_ALIAS) - len = sizeof(snd_seq_instr_t); + len = sizeof(struct snd_seq_instr); instr = snd_seq_instr_new(len, atomic); if (instr == NULL) { snd_instr_unlock_ops(list); @@ -463,8 +465,8 @@ static int instr_put(snd_seq_kinstr_ops_t *ops, if (instr->type == SNDRV_SEQ_INSTR_ATYPE_DATA) { result = ops->put(ops->private_data, instr, - (void __user *)ev->data.ext.ptr + sizeof(snd_seq_instr_header_t), - ev->data.ext.len - sizeof(snd_seq_instr_header_t), + (void __user *)ev->data.ext.ptr + sizeof(struct snd_seq_instr_header), + ev->data.ext.len - sizeof(struct snd_seq_instr_header), atomic, put.cmd); if (result < 0) { @@ -486,21 +488,21 @@ static int instr_put(snd_seq_kinstr_ops_t *ops, return result; } -static int instr_get(snd_seq_kinstr_ops_t *ops, - snd_seq_kinstr_list_t *list, - snd_seq_event_t *ev, +static int instr_get(struct snd_seq_kinstr_ops *ops, + struct snd_seq_kinstr_list *list, + struct snd_seq_event *ev, int atomic, int hop) { return -ENXIO; } -static int instr_free(snd_seq_kinstr_ops_t *ops, - snd_seq_kinstr_list_t *list, - snd_seq_event_t *ev, +static int instr_free(struct snd_seq_kinstr_ops *ops, + struct snd_seq_kinstr_list *list, + struct snd_seq_event *ev, int atomic, int hop) { - snd_seq_instr_header_t ifree; - snd_seq_kinstr_t *instr, *prev; + struct snd_seq_instr_header ifree; + struct snd_seq_kinstr *instr, *prev; int result = -EINVAL; unsigned long flags; unsigned int hash; @@ -508,9 +510,10 @@ static int instr_free(snd_seq_kinstr_ops_t *ops, if ((ev->flags & SNDRV_SEQ_EVENT_LENGTH_MASK) != SNDRV_SEQ_EVENT_LENGTH_VARUSR) goto __return; - if (ev->data.ext.len < sizeof(snd_seq_instr_header_t)) + if (ev->data.ext.len < sizeof(struct snd_seq_instr_header)) goto __return; - if (copy_from_user(&ifree, (void __user *)ev->data.ext.ptr, sizeof(snd_seq_instr_header_t))) { + if (copy_from_user(&ifree, (void __user *)ev->data.ext.ptr, + sizeof(struct snd_seq_instr_header))) { result = -EFAULT; goto __return; } @@ -548,7 +551,8 @@ static int instr_free(snd_seq_kinstr_ops_t *ops, list->hash[hash] = instr->next; } if (instr->ops && instr->ops->notify) - instr->ops->notify(instr->ops->private_data, instr, SNDRV_SEQ_INSTR_NOTIFY_REMOVE); + instr->ops->notify(instr->ops->private_data, instr, + SNDRV_SEQ_INSTR_NOTIFY_REMOVE); while (instr->use) { spin_unlock_irqrestore(&list->lock, flags); schedule_timeout_interruptible(1); @@ -565,25 +569,25 @@ static int instr_free(snd_seq_kinstr_ops_t *ops, return result; } -static int instr_list(snd_seq_kinstr_ops_t *ops, - snd_seq_kinstr_list_t *list, - snd_seq_event_t *ev, +static int instr_list(struct snd_seq_kinstr_ops *ops, + struct snd_seq_kinstr_list *list, + struct snd_seq_event *ev, int atomic, int hop) { return -ENXIO; } -static int instr_cluster(snd_seq_kinstr_ops_t *ops, - snd_seq_kinstr_list_t *list, - snd_seq_event_t *ev, +static int instr_cluster(struct snd_seq_kinstr_ops *ops, + struct snd_seq_kinstr_list *list, + struct snd_seq_event *ev, int atomic, int hop) { return -ENXIO; } -int snd_seq_instr_event(snd_seq_kinstr_ops_t *ops, - snd_seq_kinstr_list_t *list, - snd_seq_event_t *ev, +int snd_seq_instr_event(struct snd_seq_kinstr_ops *ops, + struct snd_seq_kinstr_list *list, + struct snd_seq_event *ev, int client, int atomic, int hop) diff --git a/sound/core/seq/seq_memory.c b/sound/core/seq/seq_memory.c index 8416bcffa09..40b4f679c80 100644 --- a/sound/core/seq/seq_memory.c +++ b/sound/core/seq/seq_memory.c @@ -32,16 +32,12 @@ #include "seq_info.h" #include "seq_lock.h" -/* semaphore in struct file record */ -#define semaphore_of(fp) ((fp)->f_dentry->d_inode->i_sem) - - -static inline int snd_seq_pool_available(pool_t *pool) +static inline int snd_seq_pool_available(struct snd_seq_pool *pool) { return pool->total_elements - atomic_read(&pool->counter); } -static inline int snd_seq_output_ok(pool_t *pool) +static inline int snd_seq_output_ok(struct snd_seq_pool *pool) { return snd_seq_pool_available(pool) >= pool->room; } @@ -72,7 +68,7 @@ static inline int snd_seq_output_ok(pool_t *pool) * call dump function to expand external data. */ -static int get_var_len(const snd_seq_event_t *event) +static int get_var_len(const struct snd_seq_event *event) { if ((event->flags & SNDRV_SEQ_EVENT_LENGTH_MASK) != SNDRV_SEQ_EVENT_LENGTH_VARIABLE) return -EINVAL; @@ -80,10 +76,11 @@ static int get_var_len(const snd_seq_event_t *event) return event->data.ext.len & ~SNDRV_SEQ_EXT_MASK; } -int snd_seq_dump_var_event(const snd_seq_event_t *event, snd_seq_dump_func_t func, void *private_data) +int snd_seq_dump_var_event(const struct snd_seq_event *event, + snd_seq_dump_func_t func, void *private_data) { int len, err; - snd_seq_event_cell_t *cell; + struct snd_seq_event_cell *cell; if ((len = get_var_len(event)) <= 0) return len; @@ -108,9 +105,9 @@ int snd_seq_dump_var_event(const snd_seq_event_t *event, snd_seq_dump_func_t fun return func(private_data, event->data.ext.ptr, len); } - cell = (snd_seq_event_cell_t*)event->data.ext.ptr; + cell = (struct snd_seq_event_cell *)event->data.ext.ptr; for (; len > 0 && cell; cell = cell->next) { - int size = sizeof(snd_seq_event_t); + int size = sizeof(struct snd_seq_event); if (len < size) size = len; err = func(private_data, &cell->event, size); @@ -142,7 +139,8 @@ static int seq_copy_in_user(char __user **bufptr, const void *src, int size) return 0; } -int snd_seq_expand_var_event(const snd_seq_event_t *event, int count, char *buf, int in_kernel, int size_aligned) +int snd_seq_expand_var_event(const struct snd_seq_event *event, int count, char *buf, + int in_kernel, int size_aligned) { int len, newlen; int err; @@ -174,17 +172,18 @@ int snd_seq_expand_var_event(const snd_seq_event_t *event, int count, char *buf, * release this cell, free extended data if available */ -static inline void free_cell(pool_t *pool, snd_seq_event_cell_t *cell) +static inline void free_cell(struct snd_seq_pool *pool, + struct snd_seq_event_cell *cell) { cell->next = pool->free; pool->free = cell; atomic_dec(&pool->counter); } -void snd_seq_cell_free(snd_seq_event_cell_t * cell) +void snd_seq_cell_free(struct snd_seq_event_cell * cell) { unsigned long flags; - pool_t *pool; + struct snd_seq_pool *pool; snd_assert(cell != NULL, return); pool = cell->pool; @@ -194,7 +193,7 @@ void snd_seq_cell_free(snd_seq_event_cell_t * cell) free_cell(pool, cell); if (snd_seq_ev_is_variable(&cell->event)) { if (cell->event.data.ext.len & SNDRV_SEQ_EXT_CHAINED) { - snd_seq_event_cell_t *curp, *nextptr; + struct snd_seq_event_cell *curp, *nextptr; curp = cell->event.data.ext.ptr; for (; curp; curp = nextptr) { nextptr = curp->next; @@ -215,9 +214,11 @@ void snd_seq_cell_free(snd_seq_event_cell_t * cell) /* * allocate an event cell. */ -static int snd_seq_cell_alloc(pool_t *pool, snd_seq_event_cell_t **cellp, int nonblock, struct file *file) +static int snd_seq_cell_alloc(struct snd_seq_pool *pool, + struct snd_seq_event_cell **cellp, + int nonblock, struct file *file) { - snd_seq_event_cell_t *cell; + struct snd_seq_event_cell *cell; unsigned long flags; int err = -EAGAIN; wait_queue_t wait; @@ -280,11 +281,13 @@ __error: * if the event has external data, the data is decomposed to additional * cells. */ -int snd_seq_event_dup(pool_t *pool, snd_seq_event_t *event, snd_seq_event_cell_t **cellp, int nonblock, struct file *file) +int snd_seq_event_dup(struct snd_seq_pool *pool, struct snd_seq_event *event, + struct snd_seq_event_cell **cellp, int nonblock, + struct file *file) { int ncells, err; unsigned int extlen; - snd_seq_event_cell_t *cell; + struct snd_seq_event_cell *cell; *cellp = NULL; @@ -292,7 +295,7 @@ int snd_seq_event_dup(pool_t *pool, snd_seq_event_t *event, snd_seq_event_cell_t extlen = 0; if (snd_seq_ev_is_variable(event)) { extlen = event->data.ext.len & ~SNDRV_SEQ_EXT_MASK; - ncells = (extlen + sizeof(snd_seq_event_t) - 1) / sizeof(snd_seq_event_t); + ncells = (extlen + sizeof(struct snd_seq_event) - 1) / sizeof(struct snd_seq_event); } if (ncells >= pool->total_elements) return -ENOMEM; @@ -309,18 +312,18 @@ int snd_seq_event_dup(pool_t *pool, snd_seq_event_t *event, snd_seq_event_cell_t int len = extlen; int is_chained = event->data.ext.len & SNDRV_SEQ_EXT_CHAINED; int is_usrptr = event->data.ext.len & SNDRV_SEQ_EXT_USRPTR; - snd_seq_event_cell_t *src, *tmp, *tail; + struct snd_seq_event_cell *src, *tmp, *tail; char *buf; cell->event.data.ext.len = extlen | SNDRV_SEQ_EXT_CHAINED; cell->event.data.ext.ptr = NULL; - src = (snd_seq_event_cell_t*)event->data.ext.ptr; + src = (struct snd_seq_event_cell *)event->data.ext.ptr; buf = (char *)event->data.ext.ptr; tail = NULL; while (ncells-- > 0) { - int size = sizeof(snd_seq_event_t); + int size = sizeof(struct snd_seq_event); if (len < size) size = len; err = snd_seq_cell_alloc(pool, &tmp, nonblock, file); @@ -358,7 +361,8 @@ __error: /* poll wait */ -int snd_seq_pool_poll_wait(pool_t *pool, struct file *file, poll_table *wait) +int snd_seq_pool_poll_wait(struct snd_seq_pool *pool, struct file *file, + poll_table *wait) { poll_wait(file, &pool->output_sleep, wait); return snd_seq_output_ok(pool); @@ -366,17 +370,17 @@ int snd_seq_pool_poll_wait(pool_t *pool, struct file *file, poll_table *wait) /* allocate room specified number of events */ -int snd_seq_pool_init(pool_t *pool) +int snd_seq_pool_init(struct snd_seq_pool *pool) { int cell; - snd_seq_event_cell_t *cellptr; + struct snd_seq_event_cell *cellptr; unsigned long flags; snd_assert(pool != NULL, return -EINVAL); if (pool->ptr) /* should be atomic? */ return 0; - pool->ptr = vmalloc(sizeof(snd_seq_event_cell_t) * pool->size); + pool->ptr = vmalloc(sizeof(struct snd_seq_event_cell) * pool->size); if (pool->ptr == NULL) { snd_printd("seq: malloc for sequencer events failed\n"); return -ENOMEM; @@ -402,10 +406,10 @@ int snd_seq_pool_init(pool_t *pool) } /* remove events */ -int snd_seq_pool_done(pool_t *pool) +int snd_seq_pool_done(struct snd_seq_pool *pool) { unsigned long flags; - snd_seq_event_cell_t *ptr; + struct snd_seq_event_cell *ptr; int max_count = 5 * HZ; snd_assert(pool != NULL, return -EINVAL); @@ -446,9 +450,9 @@ int snd_seq_pool_done(pool_t *pool) /* init new memory pool */ -pool_t *snd_seq_pool_new(int poolsize) +struct snd_seq_pool *snd_seq_pool_new(int poolsize) { - pool_t *pool; + struct snd_seq_pool *pool; /* create pool block */ pool = kzalloc(sizeof(*pool), GFP_KERNEL); @@ -472,9 +476,9 @@ pool_t *snd_seq_pool_new(int poolsize) } /* remove memory pool */ -int snd_seq_pool_delete(pool_t **ppool) +int snd_seq_pool_delete(struct snd_seq_pool **ppool) { - pool_t *pool = *ppool; + struct snd_seq_pool *pool = *ppool; *ppool = NULL; if (pool == NULL) @@ -497,7 +501,8 @@ void __exit snd_sequencer_memory_done(void) /* exported to seq_clientmgr.c */ -void snd_seq_info_pool(snd_info_buffer_t * buffer, pool_t *pool, char *space) +void snd_seq_info_pool(struct snd_info_buffer *buffer, + struct snd_seq_pool *pool, char *space) { if (pool == NULL) return; diff --git a/sound/core/seq/seq_memory.h b/sound/core/seq/seq_memory.h index 6c4dde5d3d6..39c60d9e1ef 100644 --- a/sound/core/seq/seq_memory.h +++ b/sound/core/seq/seq_memory.h @@ -24,23 +24,21 @@ #include <sound/seq_kernel.h> #include <linux/poll.h> -typedef struct pool pool_t; - /* container for sequencer event (internal use) */ -typedef struct snd_seq_event_cell_t { - snd_seq_event_t event; - pool_t *pool; /* used pool */ - struct snd_seq_event_cell_t *next; /* next cell */ -} snd_seq_event_cell_t; +struct snd_seq_event_cell { + struct snd_seq_event event; + struct snd_seq_pool *pool; /* used pool */ + struct snd_seq_event_cell *next; /* next cell */ +}; /* design note: the pool is a contigious block of memory, if we dynamicly want to add additional cells to the pool be better store this in another pool as we need to know the base address of the pool when releasing memory. */ -struct pool { - snd_seq_event_cell_t *ptr; /* pointer to first event chunk */ - snd_seq_event_cell_t *free; /* pointer to the head of the free list */ +struct snd_seq_pool { + struct snd_seq_event_cell *ptr; /* pointer to first event chunk */ + struct snd_seq_event_cell *free; /* pointer to the head of the free list */ int total_elements; /* pool size actually allocated */ atomic_t counter; /* cells free */ @@ -63,33 +61,34 @@ struct pool { spinlock_t lock; }; -extern void snd_seq_cell_free(snd_seq_event_cell_t* cell); +void snd_seq_cell_free(struct snd_seq_event_cell *cell); -int snd_seq_event_dup(pool_t *pool, snd_seq_event_t *event, snd_seq_event_cell_t **cellp, int nonblock, struct file *file); +int snd_seq_event_dup(struct snd_seq_pool *pool, struct snd_seq_event *event, + struct snd_seq_event_cell **cellp, int nonblock, struct file *file); /* return number of unused (free) cells */ -static inline int snd_seq_unused_cells(pool_t *pool) +static inline int snd_seq_unused_cells(struct snd_seq_pool *pool) { return pool ? pool->total_elements - atomic_read(&pool->counter) : 0; } /* return total number of allocated cells */ -static inline int snd_seq_total_cells(pool_t *pool) +static inline int snd_seq_total_cells(struct snd_seq_pool *pool) { return pool ? pool->total_elements : 0; } /* init pool - allocate events */ -int snd_seq_pool_init(pool_t *pool); +int snd_seq_pool_init(struct snd_seq_pool *pool); /* done pool - free events */ -int snd_seq_pool_done(pool_t *pool); +int snd_seq_pool_done(struct snd_seq_pool *pool); /* create pool */ -pool_t *snd_seq_pool_new(int poolsize); +struct snd_seq_pool *snd_seq_pool_new(int poolsize); /* remove pool */ -int snd_seq_pool_delete(pool_t **pool); +int snd_seq_pool_delete(struct snd_seq_pool **pool); /* init memory */ int snd_sequencer_memory_init(void); @@ -98,7 +97,7 @@ int snd_sequencer_memory_init(void); void snd_sequencer_memory_done(void); /* polling */ -int snd_seq_pool_poll_wait(pool_t *pool, struct file *file, poll_table *wait); +int snd_seq_pool_poll_wait(struct snd_seq_pool *pool, struct file *file, poll_table *wait); #endif diff --git a/sound/core/seq/seq_midi.c b/sound/core/seq/seq_midi.c index f89f40f4487..ce0df86157d 100644 --- a/sound/core/seq/seq_midi.c +++ b/sound/core/seq/seq_midi.c @@ -51,40 +51,40 @@ module_param(input_buffer_size, int, 0644); MODULE_PARM_DESC(input_buffer_size, "Input buffer size in bytes."); /* data for this midi synth driver */ -typedef struct { - snd_card_t *card; +struct seq_midisynth { + struct snd_card *card; int device; int subdevice; - snd_rawmidi_file_t input_rfile; - snd_rawmidi_file_t output_rfile; + struct snd_rawmidi_file input_rfile; + struct snd_rawmidi_file output_rfile; int seq_client; int seq_port; - snd_midi_event_t *parser; -} seq_midisynth_t; + struct snd_midi_event *parser; +}; -typedef struct { +struct seq_midisynth_client { int seq_client; int num_ports; int ports_per_device[SNDRV_RAWMIDI_DEVICES]; - seq_midisynth_t *ports[SNDRV_RAWMIDI_DEVICES]; -} seq_midisynth_client_t; + struct seq_midisynth *ports[SNDRV_RAWMIDI_DEVICES]; +}; -static seq_midisynth_client_t *synths[SNDRV_CARDS]; +static struct seq_midisynth_client *synths[SNDRV_CARDS]; static DECLARE_MUTEX(register_mutex); /* handle rawmidi input event (MIDI v1.0 stream) */ -static void snd_midi_input_event(snd_rawmidi_substream_t * substream) +static void snd_midi_input_event(struct snd_rawmidi_substream *substream) { - snd_rawmidi_runtime_t *runtime; - seq_midisynth_t *msynth; - snd_seq_event_t ev; + struct snd_rawmidi_runtime *runtime; + struct seq_midisynth *msynth; + struct snd_seq_event ev; char buf[16], *pbuf; long res, count; if (substream == NULL) return; runtime = substream->runtime; - msynth = (seq_midisynth_t *) runtime->private_data; + msynth = runtime->private_data; if (msynth == NULL) return; memset(&ev, 0, sizeof(ev)); @@ -112,9 +112,9 @@ static void snd_midi_input_event(snd_rawmidi_substream_t * substream) } } -static int dump_midi(snd_rawmidi_substream_t *substream, const char *buf, int count) +static int dump_midi(struct snd_rawmidi_substream *substream, const char *buf, int count) { - snd_rawmidi_runtime_t *runtime; + struct snd_rawmidi_runtime *runtime; int tmp; snd_assert(substream != NULL || buf != NULL, return -EINVAL); @@ -128,12 +128,12 @@ static int dump_midi(snd_rawmidi_substream_t *substream, const char *buf, int co return 0; } -static int event_process_midi(snd_seq_event_t * ev, int direct, +static int event_process_midi(struct snd_seq_event *ev, int direct, void *private_data, int atomic, int hop) { - seq_midisynth_t *msynth = (seq_midisynth_t *) private_data; + struct seq_midisynth *msynth = private_data; unsigned char msg[10]; /* buffer for constructing midi messages */ - snd_rawmidi_substream_t *substream; + struct snd_rawmidi_substream *substream; int len; snd_assert(msynth != NULL, return -EINVAL); @@ -161,8 +161,8 @@ static int event_process_midi(snd_seq_event_t * ev, int direct, } -static int snd_seq_midisynth_new(seq_midisynth_t *msynth, - snd_card_t *card, +static int snd_seq_midisynth_new(struct seq_midisynth *msynth, + struct snd_card *card, int device, int subdevice) { @@ -175,15 +175,18 @@ static int snd_seq_midisynth_new(seq_midisynth_t *msynth, } /* open associated midi device for input */ -static int midisynth_subscribe(void *private_data, snd_seq_port_subscribe_t *info) +static int midisynth_subscribe(void *private_data, struct snd_seq_port_subscribe *info) { int err; - seq_midisynth_t *msynth = (seq_midisynth_t *)private_data; - snd_rawmidi_runtime_t *runtime; - snd_rawmidi_params_t params; + struct seq_midisynth *msynth = private_data; + struct snd_rawmidi_runtime *runtime; + struct snd_rawmidi_params params; /* open midi port */ - if ((err = snd_rawmidi_kernel_open(msynth->card->number, msynth->device, msynth->subdevice, SNDRV_RAWMIDI_LFLG_INPUT, &msynth->input_rfile)) < 0) { + 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; } @@ -203,10 +206,10 @@ static int midisynth_subscribe(void *private_data, snd_seq_port_subscribe_t *inf } /* close associated midi device for input */ -static int midisynth_unsubscribe(void *private_data, snd_seq_port_subscribe_t *info) +static int midisynth_unsubscribe(void *private_data, struct snd_seq_port_subscribe *info) { int err; - seq_midisynth_t *msynth = (seq_midisynth_t *)private_data; + struct seq_midisynth *msynth = private_data; snd_assert(msynth->input_rfile.input != NULL, return -EINVAL); err = snd_rawmidi_kernel_release(&msynth->input_rfile); @@ -214,14 +217,17 @@ static int midisynth_unsubscribe(void *private_data, snd_seq_port_subscribe_t *i } /* open associated midi device for output */ -static int midisynth_use(void *private_data, snd_seq_port_subscribe_t *info) +static int midisynth_use(void *private_data, struct snd_seq_port_subscribe *info) { int err; - seq_midisynth_t *msynth = (seq_midisynth_t *)private_data; - snd_rawmidi_params_t params; + struct seq_midisynth *msynth = private_data; + struct snd_rawmidi_params params; /* open midi port */ - if ((err = snd_rawmidi_kernel_open(msynth->card->number, msynth->device, msynth->subdevice, SNDRV_RAWMIDI_LFLG_OUTPUT, &msynth->output_rfile)) < 0) { + 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; } @@ -237,9 +243,9 @@ static int midisynth_use(void *private_data, snd_seq_port_subscribe_t *info) } /* close associated midi device for output */ -static int midisynth_unuse(void *private_data, snd_seq_port_subscribe_t *info) +static int midisynth_unuse(void *private_data, struct snd_seq_port_subscribe *info) { - seq_midisynth_t *msynth = (seq_midisynth_t *)private_data; + struct seq_midisynth *msynth = private_data; unsigned char buf = 0xff; /* MIDI reset */ snd_assert(msynth->output_rfile.output != NULL, return -EINVAL); @@ -250,7 +256,7 @@ static int midisynth_unuse(void *private_data, snd_seq_port_subscribe_t *info) } /* delete given midi synth port */ -static void snd_seq_midisynth_delete(seq_midisynth_t *msynth) +static void snd_seq_midisynth_delete(struct seq_midisynth *msynth) { if (msynth == NULL) return; @@ -264,34 +270,18 @@ static void snd_seq_midisynth_delete(seq_midisynth_t *msynth) snd_midi_event_free(msynth->parser); } -/* set our client name */ -static int set_client_name(seq_midisynth_client_t *client, snd_card_t *card, - snd_rawmidi_info_t *rmidi) -{ - snd_seq_client_info_t cinfo; - const char *name; - - memset(&cinfo, 0, sizeof(cinfo)); - cinfo.client = client->seq_client; - cinfo.type = KERNEL_CLIENT; - name = rmidi->name[0] ? (const char *)rmidi->name : "External MIDI"; - strlcpy(cinfo.name, name, sizeof(cinfo.name)); - return snd_seq_kernel_client_ctl(client->seq_client, SNDRV_SEQ_IOCTL_SET_CLIENT_INFO, &cinfo); -} - /* register new midi synth port */ static int -snd_seq_midisynth_register_port(snd_seq_device_t *dev) +snd_seq_midisynth_register_port(struct snd_seq_device *dev) { - seq_midisynth_client_t *client; - seq_midisynth_t *msynth, *ms; - snd_seq_port_info_t *port; - snd_rawmidi_info_t *info; + struct seq_midisynth_client *client; + struct seq_midisynth *msynth, *ms; + struct snd_seq_port_info *port; + struct snd_rawmidi_info *info; int newclient = 0; unsigned int p, ports; - snd_seq_client_callback_t callbacks; - snd_seq_port_callback_t pcallbacks; - snd_card_t *card = dev->card; + struct snd_seq_port_callback pcallbacks; + struct snd_card *card = dev->card; int device = dev->device; unsigned int input_count = 0, output_count = 0; @@ -328,21 +318,19 @@ snd_seq_midisynth_register_port(snd_seq_device_t *dev) kfree(info); return -ENOMEM; } - memset(&callbacks, 0, sizeof(callbacks)); - callbacks.private_data = client; - callbacks.allow_input = callbacks.allow_output = 1; - client->seq_client = snd_seq_create_kernel_client(card, 0, &callbacks); + client->seq_client = + snd_seq_create_kernel_client( + card, 0, "%s", info->name[0] ? + (const char *)info->name : "External MIDI"); if (client->seq_client < 0) { kfree(client); up(®ister_mutex); kfree(info); return -ENOMEM; } - set_client_name(client, card, info); - } else if (device == 0) - set_client_name(client, card, info); /* use the first device's name */ + } - msynth = kcalloc(ports, sizeof(seq_midisynth_t), GFP_KERNEL); + msynth = kcalloc(ports, sizeof(struct seq_midisynth), GFP_KERNEL); port = kmalloc(sizeof(*port), GFP_KERNEL); if (msynth == NULL || port == NULL) goto __nomem; @@ -432,11 +420,11 @@ snd_seq_midisynth_register_port(snd_seq_device_t *dev) /* release midi synth port */ static int -snd_seq_midisynth_unregister_port(snd_seq_device_t *dev) +snd_seq_midisynth_unregister_port(struct snd_seq_device *dev) { - seq_midisynth_client_t *client; - seq_midisynth_t *msynth; - snd_card_t *card = dev->card; + struct seq_midisynth_client *client; + struct seq_midisynth *msynth; + struct snd_card *card = dev->card; int device = dev->device, p, ports; down(®ister_mutex); @@ -465,7 +453,7 @@ snd_seq_midisynth_unregister_port(snd_seq_device_t *dev) static int __init alsa_seq_midi_init(void) { - static snd_seq_dev_ops_t ops = { + static struct snd_seq_dev_ops ops = { snd_seq_midisynth_register_port, snd_seq_midisynth_unregister_port, }; diff --git a/sound/core/seq/seq_midi_emul.c b/sound/core/seq/seq_midi_emul.c index 35fe8a7e34b..d7c4fb86b9e 100644 --- a/sound/core/seq/seq_midi_emul.c +++ b/sound/core/seq/seq_midi_emul.c @@ -44,17 +44,25 @@ MODULE_DESCRIPTION("Advanced Linux Sound Architecture sequencer MIDI emulation." MODULE_LICENSE("GPL"); /* Prototypes for static functions */ -static void note_off(snd_midi_op_t *ops, void *drv, snd_midi_channel_t *chan, int note, int vel); -static void do_control(snd_midi_op_t *ops, void *private, - snd_midi_channel_set_t *chset, snd_midi_channel_t *chan, +static void note_off(struct snd_midi_op *ops, void *drv, + struct snd_midi_channel *chan, + int note, int vel); +static void do_control(struct snd_midi_op *ops, void *private, + struct snd_midi_channel_set *chset, + struct snd_midi_channel *chan, int control, int value); -static void rpn(snd_midi_op_t *ops, void *drv, snd_midi_channel_t *chan, snd_midi_channel_set_t *chset); -static void nrpn(snd_midi_op_t *ops, void *drv, snd_midi_channel_t *chan, snd_midi_channel_set_t *chset); -static void sysex(snd_midi_op_t *ops, void *private, unsigned char *sysex, int len, snd_midi_channel_set_t *chset); -static void all_sounds_off(snd_midi_op_t *ops, void *private, snd_midi_channel_t *chan); -static void all_notes_off(snd_midi_op_t *ops, void *private, snd_midi_channel_t *chan); -static void snd_midi_reset_controllers(snd_midi_channel_t *chan); -static void reset_all_channels(snd_midi_channel_set_t *chset); +static void rpn(struct snd_midi_op *ops, void *drv, struct snd_midi_channel *chan, + struct snd_midi_channel_set *chset); +static void nrpn(struct snd_midi_op *ops, void *drv, struct snd_midi_channel *chan, + struct snd_midi_channel_set *chset); +static void sysex(struct snd_midi_op *ops, void *private, unsigned char *sysex, + int len, struct snd_midi_channel_set *chset); +static void all_sounds_off(struct snd_midi_op *ops, void *private, + struct snd_midi_channel *chan); +static void all_notes_off(struct snd_midi_op *ops, void *private, + struct snd_midi_channel *chan); +static void snd_midi_reset_controllers(struct snd_midi_channel *chan); +static void reset_all_channels(struct snd_midi_channel_set *chset); /* @@ -72,10 +80,11 @@ static void reset_all_channels(snd_midi_channel_set_t *chset); * be interpreted. */ void -snd_midi_process_event(snd_midi_op_t *ops, - snd_seq_event_t *ev, snd_midi_channel_set_t *chanset) +snd_midi_process_event(struct snd_midi_op *ops, + struct snd_seq_event *ev, + struct snd_midi_channel_set *chanset) { - snd_midi_channel_t *chan; + struct snd_midi_channel *chan; void *drv; int dest_channel = 0; @@ -89,7 +98,8 @@ snd_midi_process_event(snd_midi_op_t *ops, if (snd_seq_ev_is_channel_type(ev)) { dest_channel = ev->data.note.channel; if (dest_channel >= chanset->max_channels) { - snd_printd("dest channel is %d, max is %d\n", dest_channel, chanset->max_channels); + snd_printd("dest channel is %d, max is %d\n", + dest_channel, chanset->max_channels); return; } } @@ -239,7 +249,8 @@ snd_midi_process_event(snd_midi_op_t *ops, * release note */ static void -note_off(snd_midi_op_t *ops, void *drv, snd_midi_channel_t *chan, int note, int vel) +note_off(struct snd_midi_op *ops, void *drv, struct snd_midi_channel *chan, + int note, int vel) { if (chan->gm_hold) { /* Hold this note until pedal is turned off */ @@ -260,8 +271,8 @@ note_off(snd_midi_op_t *ops, void *drv, snd_midi_channel_t *chan, int note, int * events that need to take place immediately to the driver. */ static void -do_control(snd_midi_op_t *ops, void *drv, snd_midi_channel_set_t *chset, - snd_midi_channel_t *chan, int control, int value) +do_control(struct snd_midi_op *ops, void *drv, struct snd_midi_channel_set *chset, + struct snd_midi_channel *chan, int control, int value) { int i; @@ -376,7 +387,7 @@ do_control(snd_midi_op_t *ops, void *drv, snd_midi_channel_set_t *chset, * initialize the MIDI status */ void -snd_midi_channel_set_clear(snd_midi_channel_set_t *chset) +snd_midi_channel_set_clear(struct snd_midi_channel_set *chset) { int i; @@ -384,7 +395,7 @@ snd_midi_channel_set_clear(snd_midi_channel_set_t *chset) chset->gs_master_volume = 127; for (i = 0; i < chset->max_channels; i++) { - snd_midi_channel_t *chan = chset->channels + i; + struct snd_midi_channel *chan = chset->channels + i; memset(chan->note, 0, sizeof(chan->note)); chan->midi_aftertouch = 0; @@ -407,8 +418,8 @@ snd_midi_channel_set_clear(snd_midi_channel_set_t *chset) * Process a rpn message. */ static void -rpn(snd_midi_op_t *ops, void *drv, snd_midi_channel_t *chan, - snd_midi_channel_set_t *chset) +rpn(struct snd_midi_op *ops, void *drv, struct snd_midi_channel *chan, + struct snd_midi_channel_set *chset) { int type; int val; @@ -447,8 +458,8 @@ rpn(snd_midi_op_t *ops, void *drv, snd_midi_channel_t *chan, * Process an nrpn message. */ static void -nrpn(snd_midi_op_t *ops, void *drv, snd_midi_channel_t *chan, - snd_midi_channel_set_t *chset) +nrpn(struct snd_midi_op *ops, void *drv, struct snd_midi_channel *chan, + struct snd_midi_channel_set *chset) { /* parse XG NRPNs here if possible */ if (ops->nrpn) @@ -475,7 +486,8 @@ get_channel(unsigned char cmd) * Process a sysex message. */ static void -sysex(snd_midi_op_t *ops, void *private, unsigned char *buf, int len, snd_midi_channel_set_t *chset) +sysex(struct snd_midi_op *ops, void *private, unsigned char *buf, int len, + struct snd_midi_channel_set *chset) { /* GM on */ static unsigned char gm_on_macro[] = { @@ -588,7 +600,7 @@ sysex(snd_midi_op_t *ops, void *private, unsigned char *buf, int len, snd_midi_c * all sound off */ static void -all_sounds_off(snd_midi_op_t *ops, void *drv, snd_midi_channel_t *chan) +all_sounds_off(struct snd_midi_op *ops, void *drv, struct snd_midi_channel *chan) { int n; @@ -606,7 +618,7 @@ all_sounds_off(snd_midi_op_t *ops, void *drv, snd_midi_channel_t *chan) * all notes off */ static void -all_notes_off(snd_midi_op_t *ops, void *drv, snd_midi_channel_t *chan) +all_notes_off(struct snd_midi_op *ops, void *drv, struct snd_midi_channel *chan) { int n; @@ -621,12 +633,12 @@ all_notes_off(snd_midi_op_t *ops, void *drv, snd_midi_channel_t *chan) /* * Initialise a single midi channel control block. */ -static void snd_midi_channel_init(snd_midi_channel_t *p, int n) +static void snd_midi_channel_init(struct snd_midi_channel *p, int n) { if (p == NULL) return; - memset(p, 0, sizeof(snd_midi_channel_t)); + memset(p, 0, sizeof(struct snd_midi_channel)); p->private = NULL; p->number = n; @@ -642,12 +654,12 @@ static void snd_midi_channel_init(snd_midi_channel_t *p, int n) /* * Allocate and initialise a set of midi channel control blocks. */ -static snd_midi_channel_t *snd_midi_channel_init_set(int n) +static struct snd_midi_channel *snd_midi_channel_init_set(int n) { - snd_midi_channel_t *chan; + struct snd_midi_channel *chan; int i; - chan = kmalloc(n * sizeof(snd_midi_channel_t), GFP_KERNEL); + chan = kmalloc(n * sizeof(struct snd_midi_channel), GFP_KERNEL); if (chan) { for (i = 0; i < n; i++) snd_midi_channel_init(chan+i, i); @@ -660,11 +672,11 @@ static snd_midi_channel_t *snd_midi_channel_init_set(int n) * reset all midi channels */ static void -reset_all_channels(snd_midi_channel_set_t *chset) +reset_all_channels(struct snd_midi_channel_set *chset) { int ch; for (ch = 0; ch < chset->max_channels; ch++) { - snd_midi_channel_t *chan = chset->channels + ch; + struct snd_midi_channel *chan = chset->channels + ch; snd_midi_reset_controllers(chan); chan->gm_rpn_pitch_bend_range = 256; /* 2 semitones */ chan->gm_rpn_fine_tuning = 0; @@ -681,9 +693,9 @@ reset_all_channels(snd_midi_channel_set_t *chset) /* * Allocate and initialise a midi channel set. */ -snd_midi_channel_set_t *snd_midi_channel_alloc_set(int n) +struct snd_midi_channel_set *snd_midi_channel_alloc_set(int n) { - snd_midi_channel_set_t *chset; + struct snd_midi_channel_set *chset; chset = kmalloc(sizeof(*chset), GFP_KERNEL); if (chset) { @@ -697,7 +709,7 @@ snd_midi_channel_set_t *snd_midi_channel_alloc_set(int n) /* * Reset the midi controllers on a particular channel to default values. */ -static void snd_midi_reset_controllers(snd_midi_channel_t *chan) +static void snd_midi_reset_controllers(struct snd_midi_channel *chan) { memset(chan->control, 0, sizeof(chan->control)); chan->gm_volume = 127; @@ -709,7 +721,7 @@ static void snd_midi_reset_controllers(snd_midi_channel_t *chan) /* * Free a midi channel set. */ -void snd_midi_channel_free_set(snd_midi_channel_set_t *chset) +void snd_midi_channel_free_set(struct snd_midi_channel_set *chset) { if (chset == NULL) return; diff --git a/sound/core/seq/seq_midi_event.c b/sound/core/seq/seq_midi_event.c index 2dc1aecfb42..5ff80b77690 100644 --- a/sound/core/seq/seq_midi_event.c +++ b/sound/core/seq/seq_midi_event.c @@ -41,33 +41,29 @@ MODULE_LICENSE("GPL"); /* from 8 to 15 are events for 0xf0-0xf7 */ -/* status event types */ -typedef void (*event_encode_t)(snd_midi_event_t *dev, snd_seq_event_t *ev); -typedef void (*event_decode_t)(snd_seq_event_t *ev, unsigned char *buf); - /* * prototypes */ -static void note_event(snd_midi_event_t *dev, snd_seq_event_t *ev); -static void one_param_ctrl_event(snd_midi_event_t *dev, snd_seq_event_t *ev); -static void pitchbend_ctrl_event(snd_midi_event_t *dev, snd_seq_event_t *ev); -static void two_param_ctrl_event(snd_midi_event_t *dev, snd_seq_event_t *ev); -static void one_param_event(snd_midi_event_t *dev, snd_seq_event_t *ev); -static void songpos_event(snd_midi_event_t *dev, snd_seq_event_t *ev); -static void note_decode(snd_seq_event_t *ev, unsigned char *buf); -static void one_param_decode(snd_seq_event_t *ev, unsigned char *buf); -static void pitchbend_decode(snd_seq_event_t *ev, unsigned char *buf); -static void two_param_decode(snd_seq_event_t *ev, unsigned char *buf); -static void songpos_decode(snd_seq_event_t *ev, unsigned char *buf); +static void note_event(struct snd_midi_event *dev, struct snd_seq_event *ev); +static void one_param_ctrl_event(struct snd_midi_event *dev, struct snd_seq_event *ev); +static void pitchbend_ctrl_event(struct snd_midi_event *dev, struct snd_seq_event *ev); +static void two_param_ctrl_event(struct snd_midi_event *dev, struct snd_seq_event *ev); +static void one_param_event(struct snd_midi_event *dev, struct snd_seq_event *ev); +static void songpos_event(struct snd_midi_event *dev, struct snd_seq_event *ev); +static void note_decode(struct snd_seq_event *ev, unsigned char *buf); +static void one_param_decode(struct snd_seq_event *ev, unsigned char *buf); +static void pitchbend_decode(struct snd_seq_event *ev, unsigned char *buf); +static void two_param_decode(struct snd_seq_event *ev, unsigned char *buf); +static void songpos_decode(struct snd_seq_event *ev, unsigned char *buf); /* * event list */ -static struct status_event_list_t { +static struct status_event_list { int event; int qlen; - event_encode_t encode; - event_decode_t decode; + void (*encode)(struct snd_midi_event *dev, struct snd_seq_event *ev); + void (*decode)(struct snd_seq_event *ev, unsigned char *buf); } status_event[] = { /* 0x80 - 0xf0 */ {SNDRV_SEQ_EVENT_NOTEOFF, 2, note_event, note_decode}, @@ -97,12 +93,15 @@ static struct status_event_list_t { {SNDRV_SEQ_EVENT_RESET, 0, NULL, NULL}, /* 0xff */ }; -static int extra_decode_ctrl14(snd_midi_event_t *dev, unsigned char *buf, int len, snd_seq_event_t *ev); -static int extra_decode_xrpn(snd_midi_event_t *dev, unsigned char *buf, int count, snd_seq_event_t *ev); +static int extra_decode_ctrl14(struct snd_midi_event *dev, unsigned char *buf, int len, + struct snd_seq_event *ev); +static int extra_decode_xrpn(struct snd_midi_event *dev, unsigned char *buf, int count, + struct snd_seq_event *ev); -static struct extra_event_list_t { +static struct extra_event_list { int event; - int (*decode)(snd_midi_event_t *dev, unsigned char *buf, int len, snd_seq_event_t *ev); + int (*decode)(struct snd_midi_event *dev, unsigned char *buf, int len, + struct snd_seq_event *ev); } extra_event[] = { {SNDRV_SEQ_EVENT_CONTROL14, extra_decode_ctrl14}, {SNDRV_SEQ_EVENT_NONREGPARAM, extra_decode_xrpn}, @@ -113,9 +112,9 @@ static struct extra_event_list_t { * new/delete record */ -int snd_midi_event_new(int bufsize, snd_midi_event_t **rdev) +int snd_midi_event_new(int bufsize, struct snd_midi_event **rdev) { - snd_midi_event_t *dev; + struct snd_midi_event *dev; *rdev = NULL; dev = kzalloc(sizeof(*dev), GFP_KERNEL); @@ -135,7 +134,7 @@ int snd_midi_event_new(int bufsize, snd_midi_event_t **rdev) return 0; } -void snd_midi_event_free(snd_midi_event_t *dev) +void snd_midi_event_free(struct snd_midi_event *dev) { if (dev != NULL) { kfree(dev->buf); @@ -146,14 +145,14 @@ void snd_midi_event_free(snd_midi_event_t *dev) /* * initialize record */ -static inline void reset_encode(snd_midi_event_t *dev) +static inline void reset_encode(struct snd_midi_event *dev) { dev->read = 0; dev->qlen = 0; dev->type = 0; } -void snd_midi_event_reset_encode(snd_midi_event_t *dev) +void snd_midi_event_reset_encode(struct snd_midi_event *dev) { unsigned long flags; @@ -162,7 +161,7 @@ void snd_midi_event_reset_encode(snd_midi_event_t *dev) spin_unlock_irqrestore(&dev->lock, flags); } -void snd_midi_event_reset_decode(snd_midi_event_t *dev) +void snd_midi_event_reset_decode(struct snd_midi_event *dev) { unsigned long flags; @@ -172,14 +171,14 @@ void snd_midi_event_reset_decode(snd_midi_event_t *dev) } #if 0 -void snd_midi_event_init(snd_midi_event_t *dev) +void snd_midi_event_init(struct snd_midi_event *dev) { snd_midi_event_reset_encode(dev); snd_midi_event_reset_decode(dev); } #endif /* 0 */ -void snd_midi_event_no_status(snd_midi_event_t *dev, int on) +void snd_midi_event_no_status(struct snd_midi_event *dev, int on) { dev->nostat = on ? 1 : 0; } @@ -188,7 +187,7 @@ void snd_midi_event_no_status(snd_midi_event_t *dev, int on) * resize buffer */ #if 0 -int snd_midi_event_resize_buffer(snd_midi_event_t *dev, int bufsize) +int snd_midi_event_resize_buffer(struct snd_midi_event *dev, int bufsize) { unsigned char *new_buf, *old_buf; unsigned long flags; @@ -213,7 +212,8 @@ int snd_midi_event_resize_buffer(snd_midi_event_t *dev, int bufsize) * read bytes and encode to sequencer event if finished * return the size of encoded bytes */ -long snd_midi_event_encode(snd_midi_event_t *dev, unsigned char *buf, long count, snd_seq_event_t *ev) +long snd_midi_event_encode(struct snd_midi_event *dev, unsigned char *buf, long count, + struct snd_seq_event *ev) { long result = 0; int rc; @@ -238,7 +238,8 @@ long snd_midi_event_encode(snd_midi_event_t *dev, unsigned char *buf, long count * 0 data is not finished * negative for error */ -int snd_midi_event_encode_byte(snd_midi_event_t *dev, int c, snd_seq_event_t *ev) +int snd_midi_event_encode_byte(struct snd_midi_event *dev, int c, + struct snd_seq_event *ev) { int rc = 0; unsigned long flags; @@ -303,7 +304,7 @@ int snd_midi_event_encode_byte(snd_midi_event_t *dev, int c, snd_seq_event_t *ev } /* encode note event */ -static void note_event(snd_midi_event_t *dev, snd_seq_event_t *ev) +static void note_event(struct snd_midi_event *dev, struct snd_seq_event *ev) { ev->data.note.channel = dev->buf[0] & 0x0f; ev->data.note.note = dev->buf[1]; @@ -311,21 +312,21 @@ static void note_event(snd_midi_event_t *dev, snd_seq_event_t *ev) } /* encode one parameter controls */ -static void one_param_ctrl_event(snd_midi_event_t *dev, snd_seq_event_t *ev) +static void one_param_ctrl_event(struct snd_midi_event *dev, struct snd_seq_event *ev) { ev->data.control.channel = dev->buf[0] & 0x0f; ev->data.control.value = dev->buf[1]; } /* encode pitch wheel change */ -static void pitchbend_ctrl_event(snd_midi_event_t *dev, snd_seq_event_t *ev) +static void pitchbend_ctrl_event(struct snd_midi_event *dev, struct snd_seq_event *ev) { ev->data.control.channel = dev->buf[0] & 0x0f; ev->data.control.value = (int)dev->buf[2] * 128 + (int)dev->buf[1] - 8192; } /* encode midi control change */ -static void two_param_ctrl_event(snd_midi_event_t *dev, snd_seq_event_t *ev) +static void two_param_ctrl_event(struct snd_midi_event *dev, struct snd_seq_event *ev) { ev->data.control.channel = dev->buf[0] & 0x0f; ev->data.control.param = dev->buf[1]; @@ -333,13 +334,13 @@ static void two_param_ctrl_event(snd_midi_event_t *dev, snd_seq_event_t *ev) } /* encode one parameter value*/ -static void one_param_event(snd_midi_event_t *dev, snd_seq_event_t *ev) +static void one_param_event(struct snd_midi_event *dev, struct snd_seq_event *ev) { ev->data.control.value = dev->buf[1]; } /* encode song position */ -static void songpos_event(snd_midi_event_t *dev, snd_seq_event_t *ev) +static void songpos_event(struct snd_midi_event *dev, struct snd_seq_event *ev) { ev->data.control.value = (int)dev->buf[2] * 128 + (int)dev->buf[1]; } @@ -348,7 +349,8 @@ static void songpos_event(snd_midi_event_t *dev, snd_seq_event_t *ev) * decode from a sequencer event to midi bytes * return the size of decoded midi events */ -long snd_midi_event_decode(snd_midi_event_t *dev, unsigned char *buf, long count, snd_seq_event_t *ev) +long snd_midi_event_decode(struct snd_midi_event *dev, unsigned char *buf, long count, + struct snd_seq_event *ev) { unsigned int cmd, type; @@ -404,20 +406,20 @@ long snd_midi_event_decode(snd_midi_event_t *dev, unsigned char *buf, long count /* decode note event */ -static void note_decode(snd_seq_event_t *ev, unsigned char *buf) +static void note_decode(struct snd_seq_event *ev, unsigned char *buf) { buf[0] = ev->data.note.note & 0x7f; buf[1] = ev->data.note.velocity & 0x7f; } /* decode one parameter controls */ -static void one_param_decode(snd_seq_event_t *ev, unsigned char *buf) +static void one_param_decode(struct snd_seq_event *ev, unsigned char *buf) { buf[0] = ev->data.control.value & 0x7f; } /* decode pitch wheel change */ -static void pitchbend_decode(snd_seq_event_t *ev, unsigned char *buf) +static void pitchbend_decode(struct snd_seq_event *ev, unsigned char *buf) { int value = ev->data.control.value + 8192; buf[0] = value & 0x7f; @@ -425,21 +427,22 @@ static void pitchbend_decode(snd_seq_event_t *ev, unsigned char *buf) } /* decode midi control change */ -static void two_param_decode(snd_seq_event_t *ev, unsigned char *buf) +static void two_param_decode(struct snd_seq_event *ev, unsigned char *buf) { buf[0] = ev->data.control.param & 0x7f; buf[1] = ev->data.control.value & 0x7f; } /* decode song position */ -static void songpos_decode(snd_seq_event_t *ev, unsigned char *buf) +static void songpos_decode(struct snd_seq_event *ev, unsigned char *buf) { buf[0] = ev->data.control.value & 0x7f; buf[1] = (ev->data.control.value >> 7) & 0x7f; } /* decode 14bit control */ -static int extra_decode_ctrl14(snd_midi_event_t *dev, unsigned char *buf, int count, snd_seq_event_t *ev) +static int extra_decode_ctrl14(struct snd_midi_event *dev, unsigned char *buf, + int count, struct snd_seq_event *ev) { unsigned char cmd; int idx = 0; @@ -476,7 +479,8 @@ static int extra_decode_ctrl14(snd_midi_event_t *dev, unsigned char *buf, int co } /* decode reg/nonreg param */ -static int extra_decode_xrpn(snd_midi_event_t *dev, unsigned char *buf, int count, snd_seq_event_t *ev) +static int extra_decode_xrpn(struct snd_midi_event *dev, unsigned char *buf, + int count, struct snd_seq_event *ev) { unsigned char cmd; char *cbytes; diff --git a/sound/core/seq/seq_ports.c b/sound/core/seq/seq_ports.c index 57ec31df0d1..2b384fd7967 100644 --- a/sound/core/seq/seq_ports.c +++ b/sound/core/seq/seq_ports.c @@ -56,16 +56,17 @@ much elements are in array. */ /* return pointer to port structure - port is locked if found */ -client_port_t *snd_seq_port_use_ptr(client_t *client, int num) +struct snd_seq_client_port *snd_seq_port_use_ptr(struct snd_seq_client *client, + int num) { struct list_head *p; - client_port_t *port; + struct snd_seq_client_port *port; if (client == NULL) return NULL; read_lock(&client->ports_lock); list_for_each(p, &client->ports_list_head) { - port = list_entry(p, client_port_t, list); + port = list_entry(p, struct snd_seq_client_port, list); if (port->addr.port == num) { if (port->closing) break; /* deleting now */ @@ -80,17 +81,18 @@ client_port_t *snd_seq_port_use_ptr(client_t *client, int num) /* search for the next port - port is locked if found */ -client_port_t *snd_seq_port_query_nearest(client_t *client, snd_seq_port_info_t *pinfo) +struct snd_seq_client_port *snd_seq_port_query_nearest(struct snd_seq_client *client, + struct snd_seq_port_info *pinfo) { int num; struct list_head *p; - client_port_t *port, *found; + struct snd_seq_client_port *port, *found; num = pinfo->addr.port; found = NULL; read_lock(&client->ports_lock); list_for_each(p, &client->ports_list_head) { - port = list_entry(p, client_port_t, list); + port = list_entry(p, struct snd_seq_client_port, list); if (port->addr.port < num) continue; if (port->addr.port == num) { @@ -111,8 +113,8 @@ client_port_t *snd_seq_port_query_nearest(client_t *client, snd_seq_port_info_t } -/* initialize port_subs_info_t */ -static void port_subs_info_init(port_subs_info_t *grp) +/* initialize snd_seq_port_subs_info */ +static void port_subs_info_init(struct snd_seq_port_subs_info *grp) { INIT_LIST_HEAD(&grp->list_head); grp->count = 0; @@ -125,10 +127,11 @@ static void port_subs_info_init(port_subs_info_t *grp) /* create a port, port number is returned (-1 on failure) */ -client_port_t *snd_seq_create_port(client_t *client, int port) +struct snd_seq_client_port *snd_seq_create_port(struct snd_seq_client *client, + int port) { unsigned long flags; - client_port_t *new_port; + struct snd_seq_client_port *new_port; struct list_head *l; int num = -1; @@ -159,7 +162,7 @@ client_port_t *snd_seq_create_port(client_t *client, int port) down(&client->ports_mutex); write_lock_irqsave(&client->ports_lock, flags); list_for_each(l, &client->ports_list_head) { - client_port_t *p = list_entry(l, client_port_t, list); + struct snd_seq_client_port *p = list_entry(l, struct snd_seq_client_port, list); if (p->addr.port > num) break; if (port < 0) /* auto-probe mode */ @@ -177,17 +180,24 @@ client_port_t *snd_seq_create_port(client_t *client, int port) } /* */ -enum group_type_t { +enum group_type { SRC_LIST, DEST_LIST }; -static int subscribe_port(client_t *client, client_port_t *port, port_subs_info_t *grp, snd_seq_port_subscribe_t *info, int send_ack); -static int unsubscribe_port(client_t *client, client_port_t *port, port_subs_info_t *grp, snd_seq_port_subscribe_t *info, int send_ack); +static int subscribe_port(struct snd_seq_client *client, + struct snd_seq_client_port *port, + struct snd_seq_port_subs_info *grp, + struct snd_seq_port_subscribe *info, int send_ack); +static int unsubscribe_port(struct snd_seq_client *client, + struct snd_seq_client_port *port, + struct snd_seq_port_subs_info *grp, + struct snd_seq_port_subscribe *info, int send_ack); -static client_port_t *get_client_port(snd_seq_addr_t *addr, client_t **cp) +static struct snd_seq_client_port *get_client_port(struct snd_seq_addr *addr, + struct snd_seq_client **cp) { - client_port_t *p; + struct snd_seq_client_port *p; *cp = snd_seq_client_use_ptr(addr->client); if (*cp) { p = snd_seq_port_use_ptr(*cp, addr->port); @@ -204,22 +214,24 @@ static client_port_t *get_client_port(snd_seq_addr_t *addr, client_t **cp) * remove all subscribers on the list * this is called from port_delete, for each src and dest list. */ -static void clear_subscriber_list(client_t *client, client_port_t *port, - port_subs_info_t *grp, int grptype) +static void clear_subscriber_list(struct snd_seq_client *client, + struct snd_seq_client_port *port, + struct snd_seq_port_subs_info *grp, + int grptype) { struct list_head *p, *n; down_write(&grp->list_mutex); list_for_each_safe(p, n, &grp->list_head) { - subscribers_t *subs; - client_t *c; - client_port_t *aport; + struct snd_seq_subscribers *subs; + struct snd_seq_client *c; + struct snd_seq_client_port *aport; if (grptype == SRC_LIST) { - subs = list_entry(p, subscribers_t, src_list); + subs = list_entry(p, struct snd_seq_subscribers, src_list); aport = get_client_port(&subs->info.dest, &c); } else { - subs = list_entry(p, subscribers_t, dest_list); + subs = list_entry(p, struct snd_seq_subscribers, dest_list); aport = get_client_port(&subs->info.sender, &c); } list_del(p); @@ -233,7 +245,7 @@ static void clear_subscriber_list(client_t *client, client_port_t *port, kfree(subs); } else { /* ok we got the connected port */ - port_subs_info_t *agrp; + struct snd_seq_port_subs_info *agrp; agrp = (grptype == SRC_LIST) ? &aport->c_dest : &aport->c_src; down_write(&agrp->list_mutex); if (grptype == SRC_LIST) @@ -251,7 +263,8 @@ static void clear_subscriber_list(client_t *client, client_port_t *port, } /* delete port data */ -static int port_delete(client_t *client, client_port_t *port) +static int port_delete(struct snd_seq_client *client, + struct snd_seq_client_port *port) { /* set closing flag and wait for all port access are gone */ port->closing = 1; @@ -273,16 +286,16 @@ static int port_delete(client_t *client, client_port_t *port) /* delete a port with the given port id */ -int snd_seq_delete_port(client_t *client, int port) +int snd_seq_delete_port(struct snd_seq_client *client, int port) { unsigned long flags; struct list_head *l; - client_port_t *found = NULL; + struct snd_seq_client_port *found = NULL; down(&client->ports_mutex); write_lock_irqsave(&client->ports_lock, flags); list_for_each(l, &client->ports_list_head) { - client_port_t *p = list_entry(l, client_port_t, list); + struct snd_seq_client_port *p = list_entry(l, struct snd_seq_client_port, list); if (p->addr.port == port) { /* ok found. delete from the list at first */ list_del(l); @@ -300,7 +313,7 @@ int snd_seq_delete_port(client_t *client, int port) } /* delete the all ports belonging to the given client */ -int snd_seq_delete_all_ports(client_t *client) +int snd_seq_delete_all_ports(struct snd_seq_client *client) { unsigned long flags; struct list_head deleted_list, *p, *n; @@ -323,7 +336,7 @@ int snd_seq_delete_all_ports(client_t *client) /* remove each port in deleted_list */ list_for_each_safe(p, n, &deleted_list) { - client_port_t *port = list_entry(p, client_port_t, list); + struct snd_seq_client_port *port = list_entry(p, struct snd_seq_client_port, list); list_del(p); snd_seq_system_client_ev_port_exit(port->addr.client, port->addr.port); port_delete(client, port); @@ -333,7 +346,8 @@ int snd_seq_delete_all_ports(client_t *client) } /* set port info fields */ -int snd_seq_set_port_info(client_port_t * port, snd_seq_port_info_t * info) +int snd_seq_set_port_info(struct snd_seq_client_port * port, + struct snd_seq_port_info * info) { snd_assert(port && info, return -EINVAL); @@ -361,7 +375,8 @@ int snd_seq_set_port_info(client_port_t * port, snd_seq_port_info_t * info) } /* get port info fields */ -int snd_seq_get_port_info(client_port_t * port, snd_seq_port_info_t * info) +int snd_seq_get_port_info(struct snd_seq_client_port * port, + struct snd_seq_port_info * info) { snd_assert(port && info, return -EINVAL); @@ -410,8 +425,11 @@ int snd_seq_get_port_info(client_port_t * port, snd_seq_port_info_t * info) * at each connnection/disconnection. */ -static int subscribe_port(client_t *client, client_port_t *port, port_subs_info_t *grp, - snd_seq_port_subscribe_t *info, int send_ack) +static int subscribe_port(struct snd_seq_client *client, + struct snd_seq_client_port *port, + struct snd_seq_port_subs_info *grp, + struct snd_seq_port_subscribe *info, + int send_ack) { int err = 0; @@ -432,9 +450,11 @@ static int subscribe_port(client_t *client, client_port_t *port, port_subs_info_ return err; } -static int unsubscribe_port(client_t *client, client_port_t *port, - port_subs_info_t *grp, - snd_seq_port_subscribe_t *info, int send_ack) +static int unsubscribe_port(struct snd_seq_client *client, + struct snd_seq_client_port *port, + struct snd_seq_port_subs_info *grp, + struct snd_seq_port_subscribe *info, + int send_ack) { int err = 0; @@ -453,15 +473,15 @@ static int unsubscribe_port(client_t *client, client_port_t *port, /* check if both addresses are identical */ -static inline int addr_match(snd_seq_addr_t *r, snd_seq_addr_t *s) +static inline int addr_match(struct snd_seq_addr *r, struct snd_seq_addr *s) { return (r->client == s->client) && (r->port == s->port); } /* check the two subscribe info match */ /* if flags is zero, checks only sender and destination addresses */ -static int match_subs_info(snd_seq_port_subscribe_t *r, - snd_seq_port_subscribe_t *s) +static int match_subs_info(struct snd_seq_port_subscribe *r, + struct snd_seq_port_subscribe *s) { if (addr_match(&r->sender, &s->sender) && addr_match(&r->dest, &s->dest)) { @@ -475,14 +495,16 @@ static int match_subs_info(snd_seq_port_subscribe_t *r, /* connect two ports */ -int snd_seq_port_connect(client_t *connector, - client_t *src_client, client_port_t *src_port, - client_t *dest_client, client_port_t *dest_port, - snd_seq_port_subscribe_t *info) +int snd_seq_port_connect(struct snd_seq_client *connector, + struct snd_seq_client *src_client, + struct snd_seq_client_port *src_port, + struct snd_seq_client *dest_client, + struct snd_seq_client_port *dest_port, + struct snd_seq_port_subscribe *info) { - port_subs_info_t *src = &src_port->c_src; - port_subs_info_t *dest = &dest_port->c_dest; - subscribers_t *subs; + struct snd_seq_port_subs_info *src = &src_port->c_src; + struct snd_seq_port_subs_info *dest = &dest_port->c_dest; + struct snd_seq_subscribers *subs; struct list_head *p; int err, src_called = 0; unsigned long flags; @@ -508,12 +530,12 @@ int snd_seq_port_connect(client_t *connector, goto __error; /* check whether already exists */ list_for_each(p, &src->list_head) { - subscribers_t *s = list_entry(p, subscribers_t, src_list); + struct snd_seq_subscribers *s = list_entry(p, struct snd_seq_subscribers, src_list); if (match_subs_info(info, &s->info)) goto __error; } list_for_each(p, &dest->list_head) { - subscribers_t *s = list_entry(p, subscribers_t, dest_list); + struct snd_seq_subscribers *s = list_entry(p, struct snd_seq_subscribers, dest_list); if (match_subs_info(info, &s->info)) goto __error; } @@ -554,14 +576,16 @@ int snd_seq_port_connect(client_t *connector, /* remove the connection */ -int snd_seq_port_disconnect(client_t *connector, - client_t *src_client, client_port_t *src_port, - client_t *dest_client, client_port_t *dest_port, - snd_seq_port_subscribe_t *info) +int snd_seq_port_disconnect(struct snd_seq_client *connector, + struct snd_seq_client *src_client, + struct snd_seq_client_port *src_port, + struct snd_seq_client *dest_client, + struct snd_seq_client_port *dest_port, + struct snd_seq_port_subscribe *info) { - port_subs_info_t *src = &src_port->c_src; - port_subs_info_t *dest = &dest_port->c_dest; - subscribers_t *subs; + struct snd_seq_port_subs_info *src = &src_port->c_src; + struct snd_seq_port_subs_info *dest = &dest_port->c_dest; + struct snd_seq_subscribers *subs; struct list_head *p; int err = -ENOENT; unsigned long flags; @@ -571,7 +595,7 @@ int snd_seq_port_disconnect(client_t *connector, /* look for the connection */ list_for_each(p, &src->list_head) { - subs = list_entry(p, subscribers_t, src_list); + subs = list_entry(p, struct snd_seq_subscribers, src_list); if (match_subs_info(info, &subs->info)) { write_lock_irqsave(&src->list_lock, flags); // write_lock(&dest->list_lock); // no lock yet @@ -597,15 +621,15 @@ int snd_seq_port_disconnect(client_t *connector, /* get matched subscriber */ -subscribers_t *snd_seq_port_get_subscription(port_subs_info_t *src_grp, - snd_seq_addr_t *dest_addr) +struct snd_seq_subscribers *snd_seq_port_get_subscription(struct snd_seq_port_subs_info *src_grp, + struct snd_seq_addr *dest_addr) { struct list_head *p; - subscribers_t *s, *found = NULL; + struct snd_seq_subscribers *s, *found = NULL; down_read(&src_grp->list_mutex); list_for_each(p, &src_grp->list_head) { - s = list_entry(p, subscribers_t, src_list); + s = list_entry(p, struct snd_seq_subscribers, src_list); if (addr_match(dest_addr, &s->info.dest)) { found = s; break; @@ -623,11 +647,11 @@ subscribers_t *snd_seq_port_get_subscription(port_subs_info_t *src_grp, */ /* exported */ int snd_seq_event_port_attach(int client, - snd_seq_port_callback_t *pcbp, + struct snd_seq_port_callback *pcbp, int cap, int type, int midi_channels, int midi_voices, char *portname) { - snd_seq_port_info_t portinfo; + struct snd_seq_port_info portinfo; int ret; /* Set up the port */ @@ -660,7 +684,7 @@ int snd_seq_event_port_attach(int client, /* exported */ int snd_seq_event_port_detach(int client, int port) { - snd_seq_port_info_t portinfo; + struct snd_seq_port_info portinfo; int err; memset(&portinfo, 0, sizeof(portinfo)); diff --git a/sound/core/seq/seq_ports.h b/sound/core/seq/seq_ports.h index 89fd4416f6f..9d7117118ba 100644 --- a/sound/core/seq/seq_ports.h +++ b/sound/core/seq/seq_ports.h @@ -40,37 +40,38 @@ */ -typedef struct subscribers_t { - snd_seq_port_subscribe_t info; /* additional info */ +struct snd_seq_subscribers { + struct snd_seq_port_subscribe info; /* additional info */ struct list_head src_list; /* link of sources */ struct list_head dest_list; /* link of destinations */ atomic_t ref_count; -} subscribers_t; +}; -typedef struct port_subs_info_t { +struct snd_seq_port_subs_info { struct list_head list_head; /* list of subscribed ports */ unsigned int count; /* count of subscribers */ unsigned int exclusive: 1; /* exclusive mode */ struct rw_semaphore list_mutex; rwlock_t list_lock; - snd_seq_kernel_port_open_t *open; - snd_seq_kernel_port_close_t *close; -} port_subs_info_t; + int (*open)(void *private_data, struct snd_seq_port_subscribe *info); + int (*close)(void *private_data, struct snd_seq_port_subscribe *info); +}; -typedef struct client_port_t { +struct snd_seq_client_port { - snd_seq_addr_t addr; /* client/port number */ + struct snd_seq_addr addr; /* client/port number */ struct module *owner; /* owner of this port */ char name[64]; /* port name */ struct list_head list; /* port list */ snd_use_lock_t use_lock; /* subscribers */ - port_subs_info_t c_src; /* read (sender) list */ - port_subs_info_t c_dest; /* write (dest) list */ + struct snd_seq_port_subs_info c_src; /* read (sender) list */ + struct snd_seq_port_subs_info c_dest; /* write (dest) list */ - snd_seq_kernel_port_input_t *event_input; - snd_seq_kernel_port_private_free_t *private_free; + int (*event_input)(struct snd_seq_event *ev, int direct, void *private_data, + int atomic, int hop); + void (*private_free)(void *private_data); void *private_data; unsigned int callback_all : 1; unsigned int closing : 1; @@ -87,42 +88,55 @@ typedef struct client_port_t { int midi_voices; int synth_voices; -} client_port_t; +}; + +struct snd_seq_client; /* return pointer to port structure and lock port */ -client_port_t *snd_seq_port_use_ptr(client_t *client, int num); +struct snd_seq_client_port *snd_seq_port_use_ptr(struct snd_seq_client *client, int num); /* search for next port - port is locked if found */ -client_port_t *snd_seq_port_query_nearest(client_t *client, snd_seq_port_info_t *pinfo); +struct snd_seq_client_port *snd_seq_port_query_nearest(struct snd_seq_client *client, + struct snd_seq_port_info *pinfo); /* unlock the port */ #define snd_seq_port_unlock(port) snd_use_lock_free(&(port)->use_lock) /* create a port, port number is returned (-1 on failure) */ -client_port_t *snd_seq_create_port(client_t *client, int port_index); +struct snd_seq_client_port *snd_seq_create_port(struct snd_seq_client *client, int port_index); /* delete a port */ -int snd_seq_delete_port(client_t *client, int port); +int snd_seq_delete_port(struct snd_seq_client *client, int port); /* delete all ports */ -int snd_seq_delete_all_ports(client_t *client); +int snd_seq_delete_all_ports(struct snd_seq_client *client); /* set port info fields */ -int snd_seq_set_port_info(client_port_t *port, snd_seq_port_info_t *info); +int snd_seq_set_port_info(struct snd_seq_client_port *port, + struct snd_seq_port_info *info); /* get port info fields */ -int snd_seq_get_port_info(client_port_t *port, snd_seq_port_info_t *info); +int snd_seq_get_port_info(struct snd_seq_client_port *port, + struct snd_seq_port_info *info); /* add subscriber to subscription list */ -int snd_seq_port_connect(client_t *caller, client_t *s, client_port_t *sp, client_t *d, client_port_t *dp, snd_seq_port_subscribe_t *info); +int snd_seq_port_connect(struct snd_seq_client *caller, + struct snd_seq_client *s, struct snd_seq_client_port *sp, + struct snd_seq_client *d, struct snd_seq_client_port *dp, + struct snd_seq_port_subscribe *info); /* remove subscriber from subscription list */ -int snd_seq_port_disconnect(client_t *caller, client_t *s, client_port_t *sp, client_t *d, client_port_t *dp, snd_seq_port_subscribe_t *info); +int snd_seq_port_disconnect(struct snd_seq_client *caller, + struct snd_seq_client *s, struct snd_seq_client_port *sp, + struct snd_seq_client *d, struct snd_seq_client_port *dp, + struct snd_seq_port_subscribe *info); /* subscribe port */ -int snd_seq_port_subscribe(client_port_t *port, snd_seq_port_subscribe_t *info); +int snd_seq_port_subscribe(struct snd_seq_client_port *port, + struct snd_seq_port_subscribe *info); /* get matched subscriber */ -subscribers_t *snd_seq_port_get_subscription(port_subs_info_t *src_grp, snd_seq_addr_t *dest_addr); +struct snd_seq_subscribers *snd_seq_port_get_subscription(struct snd_seq_port_subs_info *src_grp, + struct snd_seq_addr *dest_addr); #endif diff --git a/sound/core/seq/seq_prioq.c b/sound/core/seq/seq_prioq.c index cd641bca994..074418617ee 100644 --- a/sound/core/seq/seq_prioq.c +++ b/sound/core/seq/seq_prioq.c @@ -55,9 +55,9 @@ /* create new prioq (constructor) */ -prioq_t *snd_seq_prioq_new(void) +struct snd_seq_prioq *snd_seq_prioq_new(void) { - prioq_t *f; + struct snd_seq_prioq *f; f = kzalloc(sizeof(*f), GFP_KERNEL); if (f == NULL) { @@ -74,9 +74,9 @@ prioq_t *snd_seq_prioq_new(void) } /* delete prioq (destructor) */ -void snd_seq_prioq_delete(prioq_t **fifo) +void snd_seq_prioq_delete(struct snd_seq_prioq **fifo) { - prioq_t *f = *fifo; + struct snd_seq_prioq *f = *fifo; *fifo = NULL; if (f == NULL) { @@ -101,7 +101,8 @@ void snd_seq_prioq_delete(prioq_t **fifo) /* compare timestamp between events */ /* return 1 if a >= b; 0 */ -static inline int compare_timestamp(snd_seq_event_t * a, snd_seq_event_t * b) +static inline int compare_timestamp(struct snd_seq_event *a, + struct snd_seq_event *b) { if ((a->flags & SNDRV_SEQ_TIME_STAMP_MASK) == SNDRV_SEQ_TIME_STAMP_TICK) { /* compare ticks */ @@ -117,7 +118,8 @@ static inline int compare_timestamp(snd_seq_event_t * a, snd_seq_event_t * b) * zero if a = b; * positive if a > b; */ -static inline int compare_timestamp_rel(snd_seq_event_t *a, snd_seq_event_t *b) +static inline int compare_timestamp_rel(struct snd_seq_event *a, + struct snd_seq_event *b) { if ((a->flags & SNDRV_SEQ_TIME_STAMP_MASK) == SNDRV_SEQ_TIME_STAMP_TICK) { /* compare ticks */ @@ -144,9 +146,10 @@ static inline int compare_timestamp_rel(snd_seq_event_t *a, snd_seq_event_t *b) } /* enqueue cell to prioq */ -int snd_seq_prioq_cell_in(prioq_t * f, snd_seq_event_cell_t * cell) +int snd_seq_prioq_cell_in(struct snd_seq_prioq * f, + struct snd_seq_event_cell * cell) { - snd_seq_event_cell_t *cur, *prev; + struct snd_seq_event_cell *cur, *prev; unsigned long flags; int count; int prior; @@ -215,9 +218,9 @@ int snd_seq_prioq_cell_in(prioq_t * f, snd_seq_event_cell_t * cell) } /* dequeue cell from prioq */ -snd_seq_event_cell_t *snd_seq_prioq_cell_out(prioq_t * f) +struct snd_seq_event_cell *snd_seq_prioq_cell_out(struct snd_seq_prioq *f) { - snd_seq_event_cell_t *cell; + struct snd_seq_event_cell *cell; unsigned long flags; if (f == NULL) { @@ -243,7 +246,7 @@ snd_seq_event_cell_t *snd_seq_prioq_cell_out(prioq_t * f) } /* return number of events available in prioq */ -int snd_seq_prioq_avail(prioq_t * f) +int snd_seq_prioq_avail(struct snd_seq_prioq * f) { if (f == NULL) { snd_printd("oops: snd_seq_prioq_cell_in() called with NULL prioq\n"); @@ -254,7 +257,7 @@ int snd_seq_prioq_avail(prioq_t * f) /* peek at cell at the head of the prioq */ -snd_seq_event_cell_t *snd_seq_prioq_cell_peek(prioq_t * f) +struct snd_seq_event_cell *snd_seq_prioq_cell_peek(struct snd_seq_prioq * f) { if (f == NULL) { snd_printd("oops: snd_seq_prioq_cell_in() called with NULL prioq\n"); @@ -264,7 +267,8 @@ snd_seq_event_cell_t *snd_seq_prioq_cell_peek(prioq_t * f) } -static inline int prioq_match(snd_seq_event_cell_t *cell, int client, int timestamp) +static inline int prioq_match(struct snd_seq_event_cell *cell, + int client, int timestamp) { if (cell->event.source.client == client || cell->event.dest.client == client) @@ -286,12 +290,12 @@ static inline int prioq_match(snd_seq_event_cell_t *cell, int client, int timest } /* remove cells for left client */ -void snd_seq_prioq_leave(prioq_t * f, int client, int timestamp) +void snd_seq_prioq_leave(struct snd_seq_prioq * f, int client, int timestamp) { - register snd_seq_event_cell_t *cell, *next; + register struct snd_seq_event_cell *cell, *next; unsigned long flags; - snd_seq_event_cell_t *prev = NULL; - snd_seq_event_cell_t *freefirst = NULL, *freeprev = NULL, *freenext; + struct snd_seq_event_cell *prev = NULL; + struct snd_seq_event_cell *freefirst = NULL, *freeprev = NULL, *freenext; /* collect all removed cells */ spin_lock_irqsave(&f->lock, flags); @@ -338,8 +342,8 @@ void snd_seq_prioq_leave(prioq_t * f, int client, int timestamp) } } -static int prioq_remove_match(snd_seq_remove_events_t *info, - snd_seq_event_t *ev) +static int prioq_remove_match(struct snd_seq_remove_events *info, + struct snd_seq_event *ev) { int res; @@ -394,13 +398,13 @@ static int prioq_remove_match(snd_seq_remove_events_t *info, } /* remove cells matching remove criteria */ -void snd_seq_prioq_remove_events(prioq_t * f, int client, - snd_seq_remove_events_t *info) +void snd_seq_prioq_remove_events(struct snd_seq_prioq * f, int client, + struct snd_seq_remove_events *info) { - register snd_seq_event_cell_t *cell, *next; + struct snd_seq_event_cell *cell, *next; unsigned long flags; - snd_seq_event_cell_t *prev = NULL; - snd_seq_event_cell_t *freefirst = NULL, *freeprev = NULL, *freenext; + struct snd_seq_event_cell *prev = NULL; + struct snd_seq_event_cell *freefirst = NULL, *freeprev = NULL, *freenext; /* collect all removed cells */ spin_lock_irqsave(&f->lock, flags); diff --git a/sound/core/seq/seq_prioq.h b/sound/core/seq/seq_prioq.h index f12af79308b..d38bb78d934 100644 --- a/sound/core/seq/seq_prioq.h +++ b/sound/core/seq/seq_prioq.h @@ -26,37 +26,37 @@ /* === PRIOQ === */ -typedef struct { - snd_seq_event_cell_t* head; /* pointer to head of prioq */ - snd_seq_event_cell_t* tail; /* pointer to tail of prioq */ +struct snd_seq_prioq { + struct snd_seq_event_cell *head; /* pointer to head of prioq */ + struct snd_seq_event_cell *tail; /* pointer to tail of prioq */ int cells; spinlock_t lock; -} prioq_t; +}; /* create new prioq (constructor) */ -extern prioq_t *snd_seq_prioq_new(void); +struct snd_seq_prioq *snd_seq_prioq_new(void); /* delete prioq (destructor) */ -extern void snd_seq_prioq_delete(prioq_t **fifo); +void snd_seq_prioq_delete(struct snd_seq_prioq **fifo); /* enqueue cell to prioq */ -extern int snd_seq_prioq_cell_in(prioq_t *f, snd_seq_event_cell_t *cell); +int snd_seq_prioq_cell_in(struct snd_seq_prioq *f, struct snd_seq_event_cell *cell); /* dequeue cell from prioq */ -extern snd_seq_event_cell_t *snd_seq_prioq_cell_out(prioq_t *f); +struct snd_seq_event_cell *snd_seq_prioq_cell_out(struct snd_seq_prioq *f); /* return number of events available in prioq */ -extern int snd_seq_prioq_avail(prioq_t *f); +int snd_seq_prioq_avail(struct snd_seq_prioq *f); /* peek at cell at the head of the prioq */ -extern snd_seq_event_cell_t *snd_seq_prioq_cell_peek(prioq_t *f); +struct snd_seq_event_cell *snd_seq_prioq_cell_peek(struct snd_seq_prioq *f); /* client left queue */ -extern void snd_seq_prioq_leave(prioq_t *f, int client, int timestamp); +void snd_seq_prioq_leave(struct snd_seq_prioq *f, int client, int timestamp); /* Remove events */ -void snd_seq_prioq_remove_events(prioq_t * f, int client, - snd_seq_remove_events_t *info); +void snd_seq_prioq_remove_events(struct snd_seq_prioq *f, int client, + struct snd_seq_remove_events *info); #endif diff --git a/sound/core/seq/seq_queue.c b/sound/core/seq/seq_queue.c index 5f5c3cb37cb..9cf20f04554 100644 --- a/sound/core/seq/seq_queue.c +++ b/sound/core/seq/seq_queue.c @@ -29,7 +29,7 @@ * Aug. 30, 2000 Takashi Iwai * - Queues are managed in static array again, but with better way. * The API itself is identical. - * - The queue is locked when queue_t pinter is returned via + * - The queue is locked when struct snd_seq_queue pointer is returned via * queueptr(). This pointer *MUST* be released afterward by * queuefree(ptr). * - Addition of experimental sync support. @@ -48,7 +48,7 @@ #include "seq_info.h" /* list of allocated queues */ -static queue_t *queue_list[SNDRV_SEQ_MAX_QUEUES]; +static struct snd_seq_queue *queue_list[SNDRV_SEQ_MAX_QUEUES]; static DEFINE_SPINLOCK(queue_list_lock); /* number of queues allocated */ static int num_queues; @@ -61,7 +61,7 @@ int snd_seq_queue_get_cur_queues(void) /*----------------------------------------------------------------*/ /* assign queue id and insert to list */ -static int queue_list_add(queue_t *q) +static int queue_list_add(struct snd_seq_queue *q) { int i; unsigned long flags; @@ -80,9 +80,9 @@ static int queue_list_add(queue_t *q) return -1; } -static queue_t *queue_list_remove(int id, int client) +static struct snd_seq_queue *queue_list_remove(int id, int client) { - queue_t *q; + struct snd_seq_queue *q; unsigned long flags; spin_lock_irqsave(&queue_list_lock, flags); @@ -107,9 +107,9 @@ static queue_t *queue_list_remove(int id, int client) /*----------------------------------------------------------------*/ /* create new queue (constructor) */ -static queue_t *queue_new(int owner, int locked) +static struct snd_seq_queue *queue_new(int owner, int locked) { - queue_t *q; + struct snd_seq_queue *q; q = kzalloc(sizeof(*q), GFP_KERNEL); if (q == NULL) { @@ -142,7 +142,7 @@ static queue_t *queue_new(int owner, int locked) } /* delete queue (destructor) */ -static void queue_delete(queue_t *q) +static void queue_delete(struct snd_seq_queue *q) { /* stop and release the timer */ snd_seq_timer_stop(q->timer); @@ -187,7 +187,7 @@ void __exit snd_seq_queues_delete(void) */ int snd_seq_queue_alloc(int client, int locked, unsigned int info_flags) { - queue_t *q; + struct snd_seq_queue *q; q = queue_new(client, locked); if (q == NULL) @@ -204,7 +204,7 @@ int snd_seq_queue_alloc(int client, int locked, unsigned int info_flags) /* delete a queue - queue must be owned by the client */ int snd_seq_queue_delete(int client, int queueid) { - queue_t *q; + struct snd_seq_queue *q; if (queueid < 0 || queueid >= SNDRV_SEQ_MAX_QUEUES) return -EINVAL; @@ -218,9 +218,9 @@ int snd_seq_queue_delete(int client, int queueid) /* return pointer to queue structure for specified id */ -queue_t *queueptr(int queueid) +struct snd_seq_queue *queueptr(int queueid) { - queue_t *q; + struct snd_seq_queue *q; unsigned long flags; if (queueid < 0 || queueid >= SNDRV_SEQ_MAX_QUEUES) @@ -234,10 +234,10 @@ queue_t *queueptr(int queueid) } /* return the (first) queue matching with the specified name */ -queue_t *snd_seq_queue_find_name(char *name) +struct snd_seq_queue *snd_seq_queue_find_name(char *name) { int i; - queue_t *q; + struct snd_seq_queue *q; for (i = 0; i < SNDRV_SEQ_MAX_QUEUES; i++) { if ((q = queueptr(i)) != NULL) { @@ -252,10 +252,10 @@ queue_t *snd_seq_queue_find_name(char *name) /* -------------------------------------------------------- */ -void snd_seq_check_queue(queue_t *q, int atomic, int hop) +void snd_seq_check_queue(struct snd_seq_queue *q, int atomic, int hop) { unsigned long flags; - snd_seq_event_cell_t *cell; + struct snd_seq_event_cell *cell; if (q == NULL) return; @@ -273,7 +273,8 @@ void snd_seq_check_queue(queue_t *q, int atomic, int hop) __again: /* Process tick queue... */ while ((cell = snd_seq_prioq_cell_peek(q->tickq)) != NULL) { - if (snd_seq_compare_tick_time(&q->timer->tick.cur_tick, &cell->event.time.tick)) { + if (snd_seq_compare_tick_time(&q->timer->tick.cur_tick, + &cell->event.time.tick)) { cell = snd_seq_prioq_cell_out(q->tickq); if (cell) snd_seq_dispatch_event(cell, atomic, hop); @@ -286,7 +287,8 @@ void snd_seq_check_queue(queue_t *q, int atomic, int hop) /* Process time queue... */ while ((cell = snd_seq_prioq_cell_peek(q->timeq)) != NULL) { - if (snd_seq_compare_real_time(&q->timer->cur_time, &cell->event.time.time)) { + if (snd_seq_compare_real_time(&q->timer->cur_time, + &cell->event.time.time)) { cell = snd_seq_prioq_cell_out(q->timeq); if (cell) snd_seq_dispatch_event(cell, atomic, hop); @@ -309,10 +311,10 @@ void snd_seq_check_queue(queue_t *q, int atomic, int hop) /* enqueue a event to singe queue */ -int snd_seq_enqueue_event(snd_seq_event_cell_t *cell, int atomic, int hop) +int snd_seq_enqueue_event(struct snd_seq_event_cell *cell, int atomic, int hop) { int dest, err; - queue_t *q; + struct snd_seq_queue *q; snd_assert(cell != NULL, return -EINVAL); dest = cell->event.queue; /* destination queue */ @@ -327,7 +329,8 @@ int snd_seq_enqueue_event(snd_seq_event_cell_t *cell, int atomic, int hop) break; case SNDRV_SEQ_TIME_STAMP_REAL: - snd_seq_inc_real_time(&cell->event.time.time, &q->timer->cur_time); + snd_seq_inc_real_time(&cell->event.time.time, + &q->timer->cur_time); break; } cell->event.flags &= ~SNDRV_SEQ_TIME_MODE_MASK; @@ -361,7 +364,7 @@ int snd_seq_enqueue_event(snd_seq_event_cell_t *cell, int atomic, int hop) /*----------------------------------------------------------------*/ -static inline int check_access(queue_t *q, int client) +static inline int check_access(struct snd_seq_queue *q, int client) { return (q->owner == client) || (!q->locked && !q->klocked); } @@ -369,7 +372,7 @@ static inline int check_access(queue_t *q, int client) /* check if the client has permission to modify queue parameters. * if it does, lock the queue */ -static int queue_access_lock(queue_t *q, int client) +static int queue_access_lock(struct snd_seq_queue *q, int client) { unsigned long flags; int access_ok; @@ -383,7 +386,7 @@ static int queue_access_lock(queue_t *q, int client) } /* unlock the queue */ -static inline void queue_access_unlock(queue_t *q) +static inline void queue_access_unlock(struct snd_seq_queue *q) { unsigned long flags; @@ -395,7 +398,7 @@ static inline void queue_access_unlock(queue_t *q) /* exported - only checking permission */ int snd_seq_queue_check_access(int queueid, int client) { - queue_t *q = queueptr(queueid); + struct snd_seq_queue *q = queueptr(queueid); int access_ok; unsigned long flags; @@ -415,7 +418,7 @@ int snd_seq_queue_check_access(int queueid, int client) */ int snd_seq_queue_set_owner(int queueid, int client, int locked) { - queue_t *q = queueptr(queueid); + struct snd_seq_queue *q = queueptr(queueid); if (q == NULL) return -EINVAL; @@ -443,8 +446,8 @@ int snd_seq_queue_set_owner(int queueid, int client, int locked) int snd_seq_queue_timer_open(int queueid) { int result = 0; - queue_t *queue; - seq_timer_t *tmr; + struct snd_seq_queue *queue; + struct snd_seq_timer *tmr; queue = queueptr(queueid); if (queue == NULL) @@ -463,8 +466,8 @@ int snd_seq_queue_timer_open(int queueid) */ int snd_seq_queue_timer_close(int queueid) { - queue_t *queue; - seq_timer_t *tmr; + struct snd_seq_queue *queue; + struct snd_seq_timer *tmr; int result = 0; queue = queueptr(queueid); @@ -477,9 +480,10 @@ int snd_seq_queue_timer_close(int queueid) } /* change queue tempo and ppq */ -int snd_seq_queue_timer_set_tempo(int queueid, int client, snd_seq_queue_tempo_t *info) +int snd_seq_queue_timer_set_tempo(int queueid, int client, + struct snd_seq_queue_tempo *info) { - queue_t *q = queueptr(queueid); + struct snd_seq_queue *q = queueptr(queueid); int result; if (q == NULL) @@ -493,7 +497,8 @@ int snd_seq_queue_timer_set_tempo(int queueid, int client, snd_seq_queue_tempo_t if (result >= 0) result = snd_seq_timer_set_ppq(q->timer, info->ppq); if (result >= 0 && info->skew_base > 0) - result = snd_seq_timer_set_skew(q->timer, info->skew_value, info->skew_base); + result = snd_seq_timer_set_skew(q->timer, info->skew_value, + info->skew_base); queue_access_unlock(q); queuefree(q); return result; @@ -506,7 +511,7 @@ int snd_seq_queue_timer_set_tempo(int queueid, int client, snd_seq_queue_tempo_t */ int snd_seq_queue_use(int queueid, int client, int use) { - queue_t *queue; + struct snd_seq_queue *queue; queue = queueptr(queueid); if (queue == NULL) @@ -538,7 +543,7 @@ int snd_seq_queue_use(int queueid, int client, int use) */ int snd_seq_queue_is_used(int queueid, int client) { - queue_t *q; + struct snd_seq_queue *q; int result; q = queueptr(queueid); @@ -559,7 +564,7 @@ void snd_seq_queue_client_termination(int client) { unsigned long flags; int i; - queue_t *q; + struct snd_seq_queue *q; for (i = 0; i < SNDRV_SEQ_MAX_QUEUES; i++) { if ((q = queueptr(i)) == NULL) @@ -584,7 +589,7 @@ void snd_seq_queue_client_termination(int client) void snd_seq_queue_client_leave(int client) { int i; - queue_t *q; + struct snd_seq_queue *q; /* delete own queues from queue list */ for (i = 0; i < SNDRV_SEQ_MAX_QUEUES; i++) { @@ -615,7 +620,7 @@ void snd_seq_queue_client_leave(int client) void snd_seq_queue_client_leave_cells(int client) { int i; - queue_t *q; + struct snd_seq_queue *q; for (i = 0; i < SNDRV_SEQ_MAX_QUEUES; i++) { if ((q = queueptr(i)) == NULL) @@ -627,10 +632,10 @@ void snd_seq_queue_client_leave_cells(int client) } /* remove cells based on flush criteria */ -void snd_seq_queue_remove_cells(int client, snd_seq_remove_events_t *info) +void snd_seq_queue_remove_cells(int client, struct snd_seq_remove_events *info) { int i; - queue_t *q; + struct snd_seq_queue *q; for (i = 0; i < SNDRV_SEQ_MAX_QUEUES; i++) { if ((q = queueptr(i)) == NULL) @@ -650,9 +655,10 @@ void snd_seq_queue_remove_cells(int client, snd_seq_remove_events_t *info) /* * send events to all subscribed ports */ -static void queue_broadcast_event(queue_t *q, snd_seq_event_t *ev, int atomic, int hop) +static void queue_broadcast_event(struct snd_seq_queue *q, struct snd_seq_event *ev, + int atomic, int hop) { - snd_seq_event_t sev; + struct snd_seq_event sev; sev = *ev; @@ -672,7 +678,8 @@ static void queue_broadcast_event(queue_t *q, snd_seq_event_t *ev, int atomic, i * process a received queue-control event. * this function is exported for seq_sync.c. */ -static void snd_seq_queue_process_event(queue_t *q, snd_seq_event_t *ev, +static void snd_seq_queue_process_event(struct snd_seq_queue *q, + struct snd_seq_event *ev, int atomic, int hop) { switch (ev->type) { @@ -724,9 +731,9 @@ static void snd_seq_queue_process_event(queue_t *q, snd_seq_event_t *ev, * Queue control via timer control port: * this function is exported as a callback of timer port. */ -int snd_seq_control_queue(snd_seq_event_t *ev, int atomic, int hop) +int snd_seq_control_queue(struct snd_seq_event *ev, int atomic, int hop) { - queue_t *q; + struct snd_seq_queue *q; snd_assert(ev != NULL, return -EINVAL); q = queueptr(ev->data.queue.queue); @@ -749,13 +756,14 @@ int snd_seq_control_queue(snd_seq_event_t *ev, int atomic, int hop) /*----------------------------------------------------------------*/ +#ifdef CONFIG_PROC_FS /* exported to seq_info.c */ -void snd_seq_info_queues_read(snd_info_entry_t *entry, - snd_info_buffer_t * buffer) +void snd_seq_info_queues_read(struct snd_info_entry *entry, + struct snd_info_buffer *buffer) { int i, bpm; - queue_t *q; - seq_timer_t *tmr; + struct snd_seq_queue *q; + struct snd_seq_timer *tmr; for (i = 0; i < SNDRV_SEQ_MAX_QUEUES; i++) { if ((q = queueptr(i)) == NULL) @@ -782,3 +790,5 @@ void snd_seq_info_queues_read(snd_info_entry_t *entry, queuefree(q); } } +#endif /* CONFIG_PROC_FS */ + diff --git a/sound/core/seq/seq_queue.h b/sound/core/seq/seq_queue.h index ea3c54216ea..88843859938 100644 --- a/sound/core/seq/seq_queue.h +++ b/sound/core/seq/seq_queue.h @@ -30,15 +30,15 @@ #define SEQ_QUEUE_NO_OWNER (-1) -struct _snd_seq_queue { +struct snd_seq_queue { int queue; /* queue number */ char name[64]; /* name of this queue */ - prioq_t *tickq; /* midi tick event queue */ - prioq_t *timeq; /* real-time event queue */ + struct snd_seq_prioq *tickq; /* midi tick event queue */ + struct snd_seq_prioq *timeq; /* real-time event queue */ - seq_timer_t *timer; /* time keeper for this queue */ + struct snd_seq_timer *timer; /* time keeper for this queue */ int owner; /* client that 'owns' the timer */ unsigned int locked:1, /* timer is only accesibble by owner if set */ klocked:1, /* kernel lock (after START) */ @@ -83,26 +83,26 @@ void snd_seq_queue_client_termination(int client); void snd_seq_queue_client_leave(int client); /* enqueue a event received from one the clients */ -int snd_seq_enqueue_event(snd_seq_event_cell_t *cell, int atomic, int hop); +int snd_seq_enqueue_event(struct snd_seq_event_cell *cell, int atomic, int hop); /* Remove events */ void snd_seq_queue_client_leave_cells(int client); -void snd_seq_queue_remove_cells(int client, snd_seq_remove_events_t *info); +void snd_seq_queue_remove_cells(int client, struct snd_seq_remove_events *info); /* return pointer to queue structure for specified id */ -queue_t *queueptr(int queueid); +struct snd_seq_queue *queueptr(int queueid); /* unlock */ #define queuefree(q) snd_use_lock_free(&(q)->use_lock) /* return the (first) queue matching with the specified name */ -queue_t *snd_seq_queue_find_name(char *name); +struct snd_seq_queue *snd_seq_queue_find_name(char *name); /* check single queue and dispatch events */ -void snd_seq_check_queue(queue_t *q, int atomic, int hop); +void snd_seq_check_queue(struct snd_seq_queue *q, int atomic, int hop); /* access to queue's parameters */ int snd_seq_queue_check_access(int queueid, int client); -int snd_seq_queue_timer_set_tempo(int queueid, int client, snd_seq_queue_tempo_t *info); +int snd_seq_queue_timer_set_tempo(int queueid, int client, struct snd_seq_queue_tempo *info); int snd_seq_queue_set_owner(int queueid, int client, int locked); int snd_seq_queue_set_locked(int queueid, int client, int locked); int snd_seq_queue_timer_open(int queueid); @@ -110,7 +110,7 @@ int snd_seq_queue_timer_close(int queueid); int snd_seq_queue_use(int queueid, int client, int use); int snd_seq_queue_is_used(int queueid, int client); -int snd_seq_control_queue(snd_seq_event_t *ev, int atomic, int hop); +int snd_seq_control_queue(struct snd_seq_event *ev, int atomic, int hop); /* * 64bit division - for sync stuff.. diff --git a/sound/core/seq/seq_system.c b/sound/core/seq/seq_system.c index 0d9eff85ab8..b201b76e941 100644 --- a/sound/core/seq/seq_system.c +++ b/sound/core/seq/seq_system.c @@ -66,12 +66,12 @@ static int announce_port = -1; /* fill standard header data, source port & channel are filled in */ -static int setheader(snd_seq_event_t * ev, int client, int port) +static int setheader(struct snd_seq_event * ev, int client, int port) { if (announce_port < 0) return -ENODEV; - memset(ev, 0, sizeof(snd_seq_event_t)); + memset(ev, 0, sizeof(struct snd_seq_event)); ev->flags &= ~SNDRV_SEQ_EVENT_LENGTH_MASK; ev->flags |= SNDRV_SEQ_EVENT_LENGTH_FIXED; @@ -92,7 +92,7 @@ static int setheader(snd_seq_event_t * ev, int client, int port) /* entry points for broadcasting system events */ void snd_seq_system_broadcast(int client, int port, int type) { - snd_seq_event_t ev; + struct snd_seq_event ev; if (setheader(&ev, client, port) < 0) return; @@ -101,7 +101,7 @@ void snd_seq_system_broadcast(int client, int port, int type) } /* entry points for broadcasting system events */ -int snd_seq_system_notify(int client, int port, snd_seq_event_t *ev) +int snd_seq_system_notify(int client, int port, struct snd_seq_event *ev) { ev->flags = SNDRV_SEQ_EVENT_LENGTH_FIXED; ev->source.client = sysclient; @@ -112,7 +112,7 @@ int snd_seq_system_notify(int client, int port, snd_seq_event_t *ev) } /* call-back handler for timer events */ -static int event_input_timer(snd_seq_event_t * ev, int direct, void *private_data, int atomic, int hop) +static int event_input_timer(struct snd_seq_event * ev, int direct, void *private_data, int atomic, int hop) { return snd_seq_control_queue(ev, atomic, hop); } @@ -120,34 +120,19 @@ static int event_input_timer(snd_seq_event_t * ev, int direct, void *private_dat /* register our internal client */ int __init snd_seq_system_client_init(void) { + struct snd_seq_port_callback pcallbacks; + struct snd_seq_port_info *port; - snd_seq_client_callback_t callbacks; - snd_seq_port_callback_t pcallbacks; - snd_seq_client_info_t *inf; - snd_seq_port_info_t *port; - - inf = kzalloc(sizeof(*inf), GFP_KERNEL); port = kzalloc(sizeof(*port), GFP_KERNEL); - if (! inf || ! port) { - kfree(inf); - kfree(port); + if (!port) return -ENOMEM; - } - memset(&callbacks, 0, sizeof(callbacks)); memset(&pcallbacks, 0, sizeof(pcallbacks)); pcallbacks.owner = THIS_MODULE; pcallbacks.event_input = event_input_timer; /* register client */ - callbacks.allow_input = callbacks.allow_output = 1; - sysclient = snd_seq_create_kernel_client(NULL, 0, &callbacks); - - /* set our name */ - inf->client = 0; - inf->type = KERNEL_CLIENT; - strcpy(inf->name, "System"); - snd_seq_kernel_client_ctl(sysclient, SNDRV_SEQ_IOCTL_SET_CLIENT_INFO, inf); + sysclient = snd_seq_create_kernel_client(NULL, 0, "System"); /* register timer */ strcpy(port->name, "Timer"); @@ -171,7 +156,6 @@ int __init snd_seq_system_client_init(void) snd_seq_kernel_client_ctl(sysclient, SNDRV_SEQ_IOCTL_CREATE_PORT, port); announce_port = port->addr.port; - kfree(inf); kfree(port); return 0; } diff --git a/sound/core/seq/seq_system.h b/sound/core/seq/seq_system.h index 900007255bb..cf2cfa23430 100644 --- a/sound/core/seq/seq_system.h +++ b/sound/core/seq/seq_system.h @@ -34,7 +34,7 @@ void snd_seq_system_broadcast(int client, int port, int type); #define snd_seq_system_client_ev_port_exit(client, port) snd_seq_system_broadcast(client, port, SNDRV_SEQ_EVENT_PORT_EXIT) #define snd_seq_system_client_ev_port_change(client, port) snd_seq_system_broadcast(client, port, SNDRV_SEQ_EVENT_PORT_CHANGE) -int snd_seq_system_notify(int client, int port, snd_seq_event_t *ev); +int snd_seq_system_notify(int client, int port, struct snd_seq_event *ev); /* register our internal client */ int snd_seq_system_client_init(void); diff --git a/sound/core/seq/seq_timer.c b/sound/core/seq/seq_timer.c index 65b64a7c456..b4b9a132cb1 100644 --- a/sound/core/seq/seq_timer.c +++ b/sound/core/seq/seq_timer.c @@ -41,7 +41,7 @@ extern int seq_default_timer_resolution; #define SKEW_BASE 0x10000 /* 16bit shift */ -static void snd_seq_timer_set_tick_resolution(seq_timer_tick_t *tick, +static void snd_seq_timer_set_tick_resolution(struct snd_seq_timer_tick *tick, int tempo, int ppq) { if (tempo < 1000000) @@ -60,9 +60,9 @@ static void snd_seq_timer_set_tick_resolution(seq_timer_tick_t *tick, } /* create new timer (constructor) */ -seq_timer_t *snd_seq_timer_new(void) +struct snd_seq_timer *snd_seq_timer_new(void) { - seq_timer_t *tmr; + struct snd_seq_timer *tmr; tmr = kzalloc(sizeof(*tmr), GFP_KERNEL); if (tmr == NULL) { @@ -81,9 +81,9 @@ seq_timer_t *snd_seq_timer_new(void) } /* delete timer (destructor) */ -void snd_seq_timer_delete(seq_timer_t **tmr) +void snd_seq_timer_delete(struct snd_seq_timer **tmr) { - seq_timer_t *t = *tmr; + struct snd_seq_timer *t = *tmr; *tmr = NULL; if (t == NULL) { @@ -99,7 +99,7 @@ void snd_seq_timer_delete(seq_timer_t **tmr) kfree(t); } -void snd_seq_timer_defaults(seq_timer_t * tmr) +void snd_seq_timer_defaults(struct snd_seq_timer * tmr) { /* setup defaults */ tmr->ppq = 96; /* 96 PPQ */ @@ -118,7 +118,7 @@ void snd_seq_timer_defaults(seq_timer_t * tmr) tmr->skew = tmr->skew_base = SKEW_BASE; } -void snd_seq_timer_reset(seq_timer_t * tmr) +void snd_seq_timer_reset(struct snd_seq_timer * tmr) { unsigned long flags; @@ -136,13 +136,13 @@ void snd_seq_timer_reset(seq_timer_t * tmr) /* called by timer interrupt routine. the period time since previous invocation is passed */ -static void snd_seq_timer_interrupt(snd_timer_instance_t *timeri, +static void snd_seq_timer_interrupt(struct snd_timer_instance *timeri, unsigned long resolution, unsigned long ticks) { unsigned long flags; - queue_t *q = (queue_t *)timeri->callback_data; - seq_timer_t *tmr; + struct snd_seq_queue *q = timeri->callback_data; + struct snd_seq_timer *tmr; if (q == NULL) return; @@ -177,7 +177,7 @@ static void snd_seq_timer_interrupt(snd_timer_instance_t *timeri, } /* set current tempo */ -int snd_seq_timer_set_tempo(seq_timer_t * tmr, int tempo) +int snd_seq_timer_set_tempo(struct snd_seq_timer * tmr, int tempo) { unsigned long flags; @@ -194,7 +194,7 @@ int snd_seq_timer_set_tempo(seq_timer_t * tmr, int tempo) } /* set current ppq */ -int snd_seq_timer_set_ppq(seq_timer_t * tmr, int ppq) +int snd_seq_timer_set_ppq(struct snd_seq_timer * tmr, int ppq) { unsigned long flags; @@ -217,7 +217,8 @@ int snd_seq_timer_set_ppq(seq_timer_t * tmr, int ppq) } /* set current tick position */ -int snd_seq_timer_set_position_tick(seq_timer_t *tmr, snd_seq_tick_time_t position) +int snd_seq_timer_set_position_tick(struct snd_seq_timer *tmr, + snd_seq_tick_time_t position) { unsigned long flags; @@ -231,7 +232,8 @@ int snd_seq_timer_set_position_tick(seq_timer_t *tmr, snd_seq_tick_time_t positi } /* set current real-time position */ -int snd_seq_timer_set_position_time(seq_timer_t *tmr, snd_seq_real_time_t position) +int snd_seq_timer_set_position_time(struct snd_seq_timer *tmr, + snd_seq_real_time_t position) { unsigned long flags; @@ -245,7 +247,8 @@ int snd_seq_timer_set_position_time(seq_timer_t *tmr, snd_seq_real_time_t positi } /* set timer skew */ -int snd_seq_timer_set_skew(seq_timer_t *tmr, unsigned int skew, unsigned int base) +int snd_seq_timer_set_skew(struct snd_seq_timer *tmr, unsigned int skew, + unsigned int base) { unsigned long flags; @@ -262,10 +265,10 @@ int snd_seq_timer_set_skew(seq_timer_t *tmr, unsigned int skew, unsigned int bas return 0; } -int snd_seq_timer_open(queue_t *q) +int snd_seq_timer_open(struct snd_seq_queue *q) { - snd_timer_instance_t *t; - seq_timer_t *tmr; + struct snd_timer_instance *t; + struct snd_seq_timer *tmr; char str[32]; int err; @@ -282,7 +285,7 @@ int snd_seq_timer_open(queue_t *q) if (err < 0 && tmr->alsa_id.dev_class != SNDRV_TIMER_CLASS_SLAVE) { if (tmr->alsa_id.dev_class != SNDRV_TIMER_CLASS_GLOBAL || tmr->alsa_id.device != SNDRV_TIMER_GLOBAL_SYSTEM) { - snd_timer_id_t tid; + struct snd_timer_id tid; memset(&tid, 0, sizeof(tid)); tid.dev_class = SNDRV_TIMER_CLASS_GLOBAL; tid.dev_sclass = SNDRV_TIMER_SCLASS_SEQUENCER; @@ -302,9 +305,9 @@ int snd_seq_timer_open(queue_t *q) return 0; } -int snd_seq_timer_close(queue_t *q) +int snd_seq_timer_close(struct snd_seq_queue *q) { - seq_timer_t *tmr; + struct snd_seq_timer *tmr; tmr = q->timer; snd_assert(tmr != NULL, return -EINVAL); @@ -316,7 +319,7 @@ int snd_seq_timer_close(queue_t *q) return 0; } -int snd_seq_timer_stop(seq_timer_t * tmr) +int snd_seq_timer_stop(struct snd_seq_timer * tmr) { if (! tmr->timeri) return -EINVAL; @@ -327,9 +330,9 @@ int snd_seq_timer_stop(seq_timer_t * tmr) return 0; } -static int initialize_timer(seq_timer_t *tmr) +static int initialize_timer(struct snd_seq_timer *tmr) { - snd_timer_t *t; + struct snd_timer *t; unsigned long freq; t = tmr->timeri->timer; @@ -358,7 +361,7 @@ static int initialize_timer(seq_timer_t *tmr) return 0; } -int snd_seq_timer_start(seq_timer_t * tmr) +int snd_seq_timer_start(struct snd_seq_timer * tmr) { if (! tmr->timeri) return -EINVAL; @@ -373,7 +376,7 @@ int snd_seq_timer_start(seq_timer_t * tmr) return 0; } -int snd_seq_timer_continue(seq_timer_t * tmr) +int snd_seq_timer_continue(struct snd_seq_timer * tmr) { if (! tmr->timeri) return -EINVAL; @@ -391,7 +394,7 @@ int snd_seq_timer_continue(seq_timer_t * tmr) } /* return current 'real' time. use timeofday() to get better granularity. */ -snd_seq_real_time_t snd_seq_timer_get_cur_time(seq_timer_t *tmr) +snd_seq_real_time_t snd_seq_timer_get_cur_time(struct snd_seq_timer *tmr) { snd_seq_real_time_t cur_time; @@ -416,19 +419,21 @@ snd_seq_real_time_t snd_seq_timer_get_cur_time(seq_timer_t *tmr) /* TODO: use interpolation on tick queue (will only be useful for very high PPQ values) */ -snd_seq_tick_time_t snd_seq_timer_get_cur_tick(seq_timer_t *tmr) +snd_seq_tick_time_t snd_seq_timer_get_cur_tick(struct snd_seq_timer *tmr) { return tmr->tick.cur_tick; } +#ifdef CONFIG_PROC_FS /* exported to seq_info.c */ -void snd_seq_info_timer_read(snd_info_entry_t *entry, snd_info_buffer_t * buffer) +void snd_seq_info_timer_read(struct snd_info_entry *entry, + struct snd_info_buffer *buffer) { int idx; - queue_t *q; - seq_timer_t *tmr; - snd_timer_instance_t *ti; + struct snd_seq_queue *q; + struct snd_seq_timer *tmr; + struct snd_timer_instance *ti; unsigned long resolution; for (idx = 0; idx < SNDRV_SEQ_MAX_QUEUES; idx++) { @@ -447,3 +452,5 @@ void snd_seq_info_timer_read(snd_info_entry_t *entry, snd_info_buffer_t * buffer queuefree(q); } } +#endif /* CONFIG_PROC_FS */ + diff --git a/sound/core/seq/seq_timer.h b/sound/core/seq/seq_timer.h index 287ed68591d..e9ee1543c92 100644 --- a/sound/core/seq/seq_timer.h +++ b/sound/core/seq/seq_timer.h @@ -24,13 +24,13 @@ #include <sound/timer.h> #include <sound/seq_kernel.h> -typedef struct { +struct snd_seq_timer_tick { snd_seq_tick_time_t cur_tick; /* current tick */ unsigned long resolution; /* time per tick in nsec */ unsigned long fraction; /* current time per tick in nsec */ -} seq_timer_tick_t; +}; -typedef struct { +struct snd_seq_timer { /* ... tempo / offset / running state */ unsigned int running:1, /* running state of queue */ @@ -40,12 +40,12 @@ typedef struct { int ppq; /* time resolution, ticks/quarter */ snd_seq_real_time_t cur_time; /* current time */ - seq_timer_tick_t tick; /* current tick */ + struct snd_seq_timer_tick tick; /* current tick */ int tick_updated; int type; /* timer type */ - snd_timer_id_t alsa_id; /* ALSA's timer ID */ - snd_timer_instance_t *timeri; /* timer instance */ + struct snd_timer_id alsa_id; /* ALSA's timer ID */ + struct snd_timer_instance *timeri; /* timer instance */ unsigned int ticks; unsigned long preferred_resolution; /* timer resolution, ticks/sec */ @@ -55,17 +55,18 @@ typedef struct { struct timeval last_update; /* time of last clock update, used for interpolation */ spinlock_t lock; -} seq_timer_t; +}; /* create new timer (constructor) */ -extern seq_timer_t *snd_seq_timer_new(void); +struct snd_seq_timer *snd_seq_timer_new(void); /* delete timer (destructor) */ -extern void snd_seq_timer_delete(seq_timer_t **tmr); +void snd_seq_timer_delete(struct snd_seq_timer **tmr); /* */ -static inline void snd_seq_timer_update_tick(seq_timer_tick_t *tick, unsigned long resolution) +static inline void snd_seq_timer_update_tick(struct snd_seq_timer_tick *tick, + unsigned long resolution) { if (tick->resolution > 0) { tick->fraction += resolution; @@ -119,21 +120,22 @@ static inline void snd_seq_inc_time_nsec(snd_seq_real_time_t *tm, unsigned long } /* called by timer isr */ -int snd_seq_timer_open(queue_t *q); -int snd_seq_timer_close(queue_t *q); -int snd_seq_timer_midi_open(queue_t *q); -int snd_seq_timer_midi_close(queue_t *q); -void snd_seq_timer_defaults(seq_timer_t *tmr); -void snd_seq_timer_reset(seq_timer_t *tmr); -int snd_seq_timer_stop(seq_timer_t *tmr); -int snd_seq_timer_start(seq_timer_t *tmr); -int snd_seq_timer_continue(seq_timer_t *tmr); -int snd_seq_timer_set_tempo(seq_timer_t *tmr, int tempo); -int snd_seq_timer_set_ppq(seq_timer_t *tmr, int ppq); -int snd_seq_timer_set_position_tick(seq_timer_t *tmr, snd_seq_tick_time_t position); -int snd_seq_timer_set_position_time(seq_timer_t *tmr, snd_seq_real_time_t position); -int snd_seq_timer_set_skew(seq_timer_t *tmr, unsigned int skew, unsigned int base); -snd_seq_real_time_t snd_seq_timer_get_cur_time(seq_timer_t *tmr); -snd_seq_tick_time_t snd_seq_timer_get_cur_tick(seq_timer_t *tmr); +struct snd_seq_queue; +int snd_seq_timer_open(struct snd_seq_queue *q); +int snd_seq_timer_close(struct snd_seq_queue *q); +int snd_seq_timer_midi_open(struct snd_seq_queue *q); +int snd_seq_timer_midi_close(struct snd_seq_queue *q); +void snd_seq_timer_defaults(struct snd_seq_timer *tmr); +void snd_seq_timer_reset(struct snd_seq_timer *tmr); +int snd_seq_timer_stop(struct snd_seq_timer *tmr); +int snd_seq_timer_start(struct snd_seq_timer *tmr); +int snd_seq_timer_continue(struct snd_seq_timer *tmr); +int snd_seq_timer_set_tempo(struct snd_seq_timer *tmr, int tempo); +int snd_seq_timer_set_ppq(struct snd_seq_timer *tmr, int ppq); +int snd_seq_timer_set_position_tick(struct snd_seq_timer *tmr, snd_seq_tick_time_t position); +int snd_seq_timer_set_position_time(struct snd_seq_timer *tmr, snd_seq_real_time_t position); +int snd_seq_timer_set_skew(struct snd_seq_timer *tmr, unsigned int skew, unsigned int base); +snd_seq_real_time_t snd_seq_timer_get_cur_time(struct snd_seq_timer *tmr); +snd_seq_tick_time_t snd_seq_timer_get_cur_tick(struct snd_seq_timer *tmr); #endif diff --git a/sound/core/seq/seq_virmidi.c b/sound/core/seq/seq_virmidi.c index e4f512aa742..14fd1a608e1 100644 --- a/sound/core/seq/seq_virmidi.c +++ b/sound/core/seq/seq_virmidi.c @@ -56,7 +56,8 @@ MODULE_LICENSE("GPL"); /* * initialize an event record */ -static void snd_virmidi_init_event(snd_virmidi_t *vmidi, snd_seq_event_t *ev) +static void snd_virmidi_init_event(struct snd_virmidi *vmidi, + struct snd_seq_event *ev) { memset(ev, 0, sizeof(*ev)); ev->source.port = vmidi->port; @@ -76,16 +77,17 @@ static void snd_virmidi_init_event(snd_virmidi_t *vmidi, snd_seq_event_t *ev) /* * decode input event and put to read buffer of each opened file */ -static int snd_virmidi_dev_receive_event(snd_virmidi_dev_t *rdev, snd_seq_event_t *ev) +static int snd_virmidi_dev_receive_event(struct snd_virmidi_dev *rdev, + struct snd_seq_event *ev) { - snd_virmidi_t *vmidi; + struct snd_virmidi *vmidi; struct list_head *list; unsigned char msg[4]; int len; read_lock(&rdev->filelist_lock); list_for_each(list, &rdev->filelist) { - vmidi = list_entry(list, snd_virmidi_t, list); + vmidi = list_entry(list, struct snd_virmidi, list); if (!vmidi->trigger) continue; if (ev->type == SNDRV_SEQ_EVENT_SYSEX) { @@ -111,9 +113,9 @@ static int snd_virmidi_dev_receive_event(snd_virmidi_dev_t *rdev, snd_seq_event_ * SNDRV_VIRMIDI_SEQ_ATTACH. */ #if 0 -int snd_virmidi_receive(snd_rawmidi_t *rmidi, snd_seq_event_t *ev) +int snd_virmidi_receive(struct snd_rawmidi *rmidi, struct snd_seq_event *ev) { - snd_virmidi_dev_t *rdev; + struct snd_virmidi_dev *rdev; rdev = rmidi->private_data; return snd_virmidi_dev_receive_event(rdev, ev); @@ -123,10 +125,10 @@ int snd_virmidi_receive(snd_rawmidi_t *rmidi, snd_seq_event_t *ev) /* * event handler of virmidi port */ -static int snd_virmidi_event_input(snd_seq_event_t *ev, int direct, +static int snd_virmidi_event_input(struct snd_seq_event *ev, int direct, void *private_data, int atomic, int hop) { - snd_virmidi_dev_t *rdev; + struct snd_virmidi_dev *rdev; rdev = private_data; if (!(rdev->flags & SNDRV_VIRMIDI_USE)) @@ -137,9 +139,9 @@ static int snd_virmidi_event_input(snd_seq_event_t *ev, int direct, /* * trigger rawmidi stream for input */ -static void snd_virmidi_input_trigger(snd_rawmidi_substream_t * substream, int up) +static void snd_virmidi_input_trigger(struct snd_rawmidi_substream *substream, int up) { - snd_virmidi_t *vmidi = substream->runtime->private_data; + struct snd_virmidi *vmidi = substream->runtime->private_data; if (up) { vmidi->trigger = 1; @@ -151,9 +153,9 @@ static void snd_virmidi_input_trigger(snd_rawmidi_substream_t * substream, int u /* * trigger rawmidi stream for output */ -static void snd_virmidi_output_trigger(snd_rawmidi_substream_t * substream, int up) +static void snd_virmidi_output_trigger(struct snd_rawmidi_substream *substream, int up) { - snd_virmidi_t *vmidi = substream->runtime->private_data; + struct snd_virmidi *vmidi = substream->runtime->private_data; int count, res; unsigned char buf[32], *pbuf; @@ -198,11 +200,11 @@ static void snd_virmidi_output_trigger(snd_rawmidi_substream_t * substream, int /* * open rawmidi handle for input */ -static int snd_virmidi_input_open(snd_rawmidi_substream_t * substream) +static int snd_virmidi_input_open(struct snd_rawmidi_substream *substream) { - snd_virmidi_dev_t *rdev = substream->rmidi->private_data; - snd_rawmidi_runtime_t *runtime = substream->runtime; - snd_virmidi_t *vmidi; + struct snd_virmidi_dev *rdev = substream->rmidi->private_data; + struct snd_rawmidi_runtime *runtime = substream->runtime; + struct snd_virmidi *vmidi; unsigned long flags; vmidi = kzalloc(sizeof(*vmidi), GFP_KERNEL); @@ -227,11 +229,11 @@ static int snd_virmidi_input_open(snd_rawmidi_substream_t * substream) /* * open rawmidi handle for output */ -static int snd_virmidi_output_open(snd_rawmidi_substream_t * substream) +static int snd_virmidi_output_open(struct snd_rawmidi_substream *substream) { - snd_virmidi_dev_t *rdev = substream->rmidi->private_data; - snd_rawmidi_runtime_t *runtime = substream->runtime; - snd_virmidi_t *vmidi; + struct snd_virmidi_dev *rdev = substream->rmidi->private_data; + struct snd_rawmidi_runtime *runtime = substream->runtime; + struct snd_virmidi *vmidi; vmidi = kzalloc(sizeof(*vmidi), GFP_KERNEL); if (vmidi == NULL) @@ -253,9 +255,9 @@ static int snd_virmidi_output_open(snd_rawmidi_substream_t * substream) /* * close rawmidi handle for input */ -static int snd_virmidi_input_close(snd_rawmidi_substream_t * substream) +static int snd_virmidi_input_close(struct snd_rawmidi_substream *substream) { - snd_virmidi_t *vmidi = substream->runtime->private_data; + struct snd_virmidi *vmidi = substream->runtime->private_data; snd_midi_event_free(vmidi->parser); list_del(&vmidi->list); substream->runtime->private_data = NULL; @@ -266,9 +268,9 @@ static int snd_virmidi_input_close(snd_rawmidi_substream_t * substream) /* * close rawmidi handle for output */ -static int snd_virmidi_output_close(snd_rawmidi_substream_t * substream) +static int snd_virmidi_output_close(struct snd_rawmidi_substream *substream) { - snd_virmidi_t *vmidi = substream->runtime->private_data; + struct snd_virmidi *vmidi = substream->runtime->private_data; snd_midi_event_free(vmidi->parser); substream->runtime->private_data = NULL; kfree(vmidi); @@ -278,9 +280,10 @@ static int snd_virmidi_output_close(snd_rawmidi_substream_t * substream) /* * subscribe callback - allow output to rawmidi device */ -static int snd_virmidi_subscribe(void *private_data, snd_seq_port_subscribe_t *info) +static int snd_virmidi_subscribe(void *private_data, + struct snd_seq_port_subscribe *info) { - snd_virmidi_dev_t *rdev; + struct snd_virmidi_dev *rdev; rdev = private_data; if (!try_module_get(rdev->card->module)) @@ -292,9 +295,10 @@ static int snd_virmidi_subscribe(void *private_data, snd_seq_port_subscribe_t *i /* * unsubscribe callback - disallow output to rawmidi device */ -static int snd_virmidi_unsubscribe(void *private_data, snd_seq_port_subscribe_t *info) +static int snd_virmidi_unsubscribe(void *private_data, + struct snd_seq_port_subscribe *info) { - snd_virmidi_dev_t *rdev; + struct snd_virmidi_dev *rdev; rdev = private_data; rdev->flags &= ~SNDRV_VIRMIDI_SUBSCRIBE; @@ -306,9 +310,10 @@ static int snd_virmidi_unsubscribe(void *private_data, snd_seq_port_subscribe_t /* * use callback - allow input to rawmidi device */ -static int snd_virmidi_use(void *private_data, snd_seq_port_subscribe_t *info) +static int snd_virmidi_use(void *private_data, + struct snd_seq_port_subscribe *info) { - snd_virmidi_dev_t *rdev; + struct snd_virmidi_dev *rdev; rdev = private_data; if (!try_module_get(rdev->card->module)) @@ -320,9 +325,10 @@ static int snd_virmidi_use(void *private_data, snd_seq_port_subscribe_t *info) /* * unuse callback - disallow input to rawmidi device */ -static int snd_virmidi_unuse(void *private_data, snd_seq_port_subscribe_t *info) +static int snd_virmidi_unuse(void *private_data, + struct snd_seq_port_subscribe *info) { - snd_virmidi_dev_t *rdev; + struct snd_virmidi_dev *rdev; rdev = private_data; rdev->flags &= ~SNDRV_VIRMIDI_USE; @@ -335,13 +341,13 @@ static int snd_virmidi_unuse(void *private_data, snd_seq_port_subscribe_t *info) * Register functions */ -static snd_rawmidi_ops_t snd_virmidi_input_ops = { +static struct snd_rawmidi_ops snd_virmidi_input_ops = { .open = snd_virmidi_input_open, .close = snd_virmidi_input_close, .trigger = snd_virmidi_input_trigger, }; -static snd_rawmidi_ops_t snd_virmidi_output_ops = { +static struct snd_rawmidi_ops snd_virmidi_output_ops = { .open = snd_virmidi_output_open, .close = snd_virmidi_output_close, .trigger = snd_virmidi_output_trigger, @@ -350,43 +356,32 @@ static snd_rawmidi_ops_t snd_virmidi_output_ops = { /* * create a sequencer client and a port */ -static int snd_virmidi_dev_attach_seq(snd_virmidi_dev_t *rdev) +static int snd_virmidi_dev_attach_seq(struct snd_virmidi_dev *rdev) { int client; - snd_seq_client_callback_t callbacks; - snd_seq_port_callback_t pcallbacks; - snd_seq_client_info_t *info; - snd_seq_port_info_t *pinfo; + struct snd_seq_port_callback pcallbacks; + struct snd_seq_port_info *pinfo; int err; if (rdev->client >= 0) return 0; - info = kmalloc(sizeof(*info), GFP_KERNEL); pinfo = kmalloc(sizeof(*pinfo), GFP_KERNEL); - if (! info || ! pinfo) { + if (!pinfo) { err = -ENOMEM; goto __error; } - memset(&callbacks, 0, sizeof(callbacks)); - callbacks.private_data = rdev; - callbacks.allow_input = 1; - callbacks.allow_output = 1; - client = snd_seq_create_kernel_client(rdev->card, rdev->device, &callbacks); + client = snd_seq_create_kernel_client(rdev->card, rdev->device, + "%s %d-%d", rdev->rmidi->name, + rdev->card->number, + rdev->device); if (client < 0) { err = client; goto __error; } rdev->client = client; - /* set client name */ - memset(info, 0, sizeof(*info)); - info->client = client; - info->type = KERNEL_CLIENT; - sprintf(info->name, "%s %d-%d", rdev->rmidi->name, rdev->card->number, rdev->device); - snd_seq_kernel_client_ctl(client, SNDRV_SEQ_IOCTL_SET_CLIENT_INFO, info); - /* create a port */ memset(pinfo, 0, sizeof(*pinfo)); pinfo->addr.client = client; @@ -417,7 +412,6 @@ static int snd_virmidi_dev_attach_seq(snd_virmidi_dev_t *rdev) err = 0; /* success */ __error: - kfree(info); kfree(pinfo); return err; } @@ -426,7 +420,7 @@ static int snd_virmidi_dev_attach_seq(snd_virmidi_dev_t *rdev) /* * release the sequencer client */ -static void snd_virmidi_dev_detach_seq(snd_virmidi_dev_t *rdev) +static void snd_virmidi_dev_detach_seq(struct snd_virmidi_dev *rdev) { if (rdev->client >= 0) { snd_seq_delete_kernel_client(rdev->client); @@ -437,9 +431,9 @@ static void snd_virmidi_dev_detach_seq(snd_virmidi_dev_t *rdev) /* * register the device */ -static int snd_virmidi_dev_register(snd_rawmidi_t *rmidi) +static int snd_virmidi_dev_register(struct snd_rawmidi *rmidi) { - snd_virmidi_dev_t *rdev = rmidi->private_data; + struct snd_virmidi_dev *rdev = rmidi->private_data; int err; switch (rdev->seq_mode) { @@ -464,9 +458,9 @@ static int snd_virmidi_dev_register(snd_rawmidi_t *rmidi) /* * unregister the device */ -static int snd_virmidi_dev_unregister(snd_rawmidi_t *rmidi) +static int snd_virmidi_dev_unregister(struct snd_rawmidi *rmidi) { - snd_virmidi_dev_t *rdev = rmidi->private_data; + struct snd_virmidi_dev *rdev = rmidi->private_data; if (rdev->seq_mode == SNDRV_VIRMIDI_SEQ_DISPATCH) snd_virmidi_dev_detach_seq(rdev); @@ -476,7 +470,7 @@ static int snd_virmidi_dev_unregister(snd_rawmidi_t *rmidi) /* * */ -static snd_rawmidi_global_ops_t snd_virmidi_global_ops = { +static struct snd_rawmidi_global_ops snd_virmidi_global_ops = { .dev_register = snd_virmidi_dev_register, .dev_unregister = snd_virmidi_dev_unregister, }; @@ -484,9 +478,9 @@ static snd_rawmidi_global_ops_t snd_virmidi_global_ops = { /* * free device */ -static void snd_virmidi_free(snd_rawmidi_t *rmidi) +static void snd_virmidi_free(struct snd_rawmidi *rmidi) { - snd_virmidi_dev_t *rdev = rmidi->private_data; + struct snd_virmidi_dev *rdev = rmidi->private_data; kfree(rdev); } @@ -495,10 +489,10 @@ static void snd_virmidi_free(snd_rawmidi_t *rmidi) * */ /* exported */ -int snd_virmidi_new(snd_card_t *card, int device, snd_rawmidi_t **rrmidi) +int snd_virmidi_new(struct snd_card *card, int device, struct snd_rawmidi **rrmidi) { - snd_rawmidi_t *rmidi; - snd_virmidi_dev_t *rdev; + struct snd_rawmidi *rmidi; + struct snd_virmidi_dev *rdev; int err; *rrmidi = NULL; diff --git a/sound/core/sound.c b/sound/core/sound.c index 6e7cad1e947..a8eda02bcf1 100644 --- a/sound/core/sound.c +++ b/sound/core/sound.c @@ -23,6 +23,7 @@ #include <linux/init.h> #include <linux/slab.h> #include <linux/time.h> +#include <linux/device.h> #include <linux/moduleparam.h> #include <sound/core.h> #include <sound/minors.h> @@ -32,7 +33,6 @@ #include <sound/initval.h> #include <linux/kmod.h> #include <linux/devfs_fs_kernel.h> -#include <linux/platform_device.h> #define SNDRV_OS_MINORS 256 @@ -60,8 +60,7 @@ MODULE_ALIAS_CHARDEV_MAJOR(CONFIG_SND_MAJOR); */ int snd_ecards_limit; -static struct list_head snd_minors_hash[SNDRV_CARDS]; - +static struct snd_minor *snd_minors[SNDRV_OS_MINORS]; static DECLARE_MUTEX(sound_mutex); extern struct class *sound_class; @@ -108,44 +107,61 @@ static void snd_request_other(int minor) #endif /* request_module support */ -static snd_minor_t *snd_minor_search(int minor) +/** + * 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 list_head *list; - snd_minor_t *mptr; + struct snd_minor *mreg; + void *private_data; - list_for_each(list, &snd_minors_hash[SNDRV_MINOR_CARD(minor)]) { - mptr = list_entry(list, snd_minor_t, list); - if (mptr->number == minor) - return mptr; - } - return NULL; + 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); - int card = SNDRV_MINOR_CARD(minor); - int dev = SNDRV_MINOR_DEVICE(minor); - snd_minor_t *mptr = NULL; + unsigned int minor = iminor(inode); + struct snd_minor *mptr = NULL; struct file_operations *old_fops; int err = 0; - if (dev != SNDRV_MINOR_GLOBAL) { - if (snd_cards[card] == NULL) { + if (minor > ARRAY_SIZE(snd_minors)) + return -ENODEV; + mptr = snd_minors[minor]; + if (mptr == NULL) { #ifdef CONFIG_KMOD - snd_request_card(card); + int dev = SNDRV_MINOR_DEVICE(minor); + if (dev == SNDRV_MINOR_CONTROL) { + /* /dev/aloadC? */ + int card = SNDRV_MINOR_CARD(minor); if (snd_cards[card] == NULL) -#endif - return -ENODEV; - } - } else { -#ifdef CONFIG_KMOD - if ((mptr = snd_minor_search(minor)) == NULL) + snd_request_card(card); + } else if (dev == SNDRV_MINOR_GLOBAL) { + /* /dev/aloadSEQ */ snd_request_other(minor); + } +#ifndef CONFIG_SND_DYNAMIC_MINORS + /* /dev/snd/{controlC?,seq} */ + mptr = snd_minors[minor]; + if (mptr == NULL) #endif +#endif + return -ENODEV; } - if (mptr == NULL && (mptr = snd_minor_search(minor)) == NULL) - return -ENODEV; old_fops = file->f_op; file->f_op = fops_get(mptr->f_ops); if (file->f_op->open) @@ -164,7 +180,23 @@ static struct file_operations snd_fops = .open = snd_open }; -static int snd_kernel_minor(int type, snd_card_t * card, int dev) +#ifdef CONFIG_SND_DYNAMIC_MINORS +static int snd_find_free_minor(void) +{ + int minor; + + for (minor = 0; minor < ARRAY_SIZE(snd_minors); ++minor) { + /* skip minors still used statically for autoloading devices */ + if (SNDRV_MINOR_DEVICE(minor) == SNDRV_MINOR_CONTROL || + minor == SNDRV_MINOR_SEQUENCER) + continue; + if (!snd_minors[minor]) + return minor; + } + return -EBUSY; +} +#else +static int snd_kernel_minor(int type, struct snd_card *card, int dev) { int minor; @@ -190,13 +222,15 @@ static int snd_kernel_minor(int type, snd_card_t * card, int dev) snd_assert(minor >= 0 && minor < SNDRV_OS_MINORS, return -EINVAL); return minor; } +#endif /** * snd_register_device - Register the ALSA device file for the card * @type: the device type, SNDRV_DEVICE_TYPE_XXX * @card: the card instance * @dev: the device index - * @reg: the snd_minor_t record + * @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. @@ -204,30 +238,39 @@ static int snd_kernel_minor(int type, snd_card_t * card, int dev) * * Retrurns zero if successful, or a negative error code on failure. */ -int snd_register_device(int type, snd_card_t * card, int dev, snd_minor_t * reg, const char *name) +int snd_register_device(int type, struct snd_card *card, int dev, + struct file_operations *f_ops, void *private_data, + const char *name) { - int minor = snd_kernel_minor(type, card, dev); - snd_minor_t *preg; + int minor; + struct snd_minor *preg; struct device *device = NULL; - if (minor < 0) - return minor; snd_assert(name, return -EINVAL); - preg = (snd_minor_t *)kmalloc(sizeof(snd_minor_t) + strlen(name) + 1, GFP_KERNEL); + preg = kmalloc(sizeof(struct snd_minor) + strlen(name) + 1, GFP_KERNEL); if (preg == NULL) return -ENOMEM; - *preg = *reg; - preg->number = minor; + preg->type = type; + 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_minor_search(minor)) { +#ifdef CONFIG_SND_DYNAMIC_MINORS + minor = snd_find_free_minor(); +#else + minor = snd_kernel_minor(type, card, dev); + if (minor >= 0 && snd_minors[minor]) + minor = -EBUSY; +#endif + if (minor < 0) { up(&sound_mutex); kfree(preg); - return -EBUSY; + return minor; } - list_add_tail(&preg->list, &snd_minors_hash[SNDRV_MINOR_CARD(minor)]); - if (strncmp(name, "controlC", 8) || card->number >= cards_limit) + snd_minors[minor] = preg; + if (type != SNDRV_DEVICE_TYPE_CONTROL || preg->card >= cards_limit) devfs_mk_cdev(MKDEV(major, minor), S_IFCHR | device_mode, "snd/%s", name); if (card) device = card->dev; @@ -248,61 +291,92 @@ int snd_register_device(int type, snd_card_t * card, int dev, snd_minor_t * reg, * * Returns zero if sucecessful, or a negative error code on failure */ -int snd_unregister_device(int type, snd_card_t * card, int dev) +int snd_unregister_device(int type, struct snd_card *card, int dev) { - int minor = snd_kernel_minor(type, card, dev); - snd_minor_t *mptr; + int cardnum, minor; + struct snd_minor *mptr; - if (minor < 0) - return minor; + cardnum = card ? card->number : -1; down(&sound_mutex); - if ((mptr = snd_minor_search(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; } - if (strncmp(mptr->name, "controlC", 8) || card->number >= cards_limit) /* created in sound.c */ + if (mptr->type != SNDRV_DEVICE_TYPE_CONTROL || + mptr->card >= cards_limit) /* created in sound.c */ devfs_remove("snd/%s", mptr->name); class_device_destroy(sound_class, MKDEV(major, minor)); - list_del(&mptr->list); + snd_minors[minor] = NULL; up(&sound_mutex); kfree(mptr); return 0; } +#ifdef CONFIG_PROC_FS /* * INFO PART */ -static snd_info_entry_t *snd_minor_info_entry = NULL; +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(snd_info_entry_t *entry, snd_info_buffer_t * buffer) +static void snd_minor_info_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer) { - int card, device; - struct list_head *list; - snd_minor_t *mptr; + int minor; + struct snd_minor *mptr; down(&sound_mutex); - for (card = 0; card < SNDRV_CARDS; card++) { - list_for_each(list, &snd_minors_hash[card]) { - mptr = list_entry(list, snd_minor_t, 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); - else - snd_iprintf(buffer, "%3i: [%i] : %s\n", mptr->number, card, mptr->comment); - } else { - snd_iprintf(buffer, "%3i: : %s\n", mptr->number, mptr->comment); - } - } + for (minor = 0; minor < SNDRV_OS_MINORS; ++minor) { + if (!(mptr = snd_minors[minor])) + continue; + if (mptr->card >= 0) { + if (mptr->device >= 0) + snd_iprintf(buffer, "%3i: [%2i-%2i]: %s\n", + minor, mptr->card, mptr->device, + snd_device_type_name(mptr->type)); + else + snd_iprintf(buffer, "%3i: [%2i] : %s\n", + minor, mptr->card, + snd_device_type_name(mptr->type)); + } else + snd_iprintf(buffer, "%3i: : %s\n", minor, + snd_device_type_name(mptr->type)); } up(&sound_mutex); } int __init snd_minor_info_init(void) { - snd_info_entry_t *entry; + struct snd_info_entry *entry; entry = snd_info_create_module_entry(THIS_MODULE, "devices", NULL); if (entry) { @@ -323,27 +397,18 @@ int __exit snd_minor_info_done(void) snd_info_unregister(snd_minor_info_entry); return 0; } +#endif /* CONFIG_PROC_FS */ /* * INIT PART */ -#ifdef CONFIG_SND_GENERIC_DRIVER -extern struct platform_driver snd_generic_driver; -#endif - static int __init alsa_sound_init(void) { short controlnum; - int err; - int card; snd_major = major; snd_ecards_limit = cards_limit; - for (card = 0; card < SNDRV_CARDS; card++) - INIT_LIST_HEAD(&snd_minors_hash[card]); - if ((err = snd_oss_init_module()) < 0) - return err; devfs_mk_dir("snd"); if (register_chrdev(major, "alsa", &snd_fops)) { snd_printk(KERN_ERR "unable to register native major device number %d\n", major); @@ -356,9 +421,6 @@ static int __init alsa_sound_init(void) return -ENOMEM; } snd_info_minor_register(); -#ifdef CONFIG_SND_GENERIC_DRIVER - platform_driver_register(&snd_generic_driver); -#endif for (controlnum = 0; controlnum < cards_limit; controlnum++) devfs_mk_cdev(MKDEV(major, controlnum<<5), S_IFCHR | device_mode, "snd/controlC%d", controlnum); #ifndef MODULE @@ -374,9 +436,6 @@ static void __exit alsa_sound_exit(void) for (controlnum = 0; controlnum < cards_limit; controlnum++) devfs_remove("snd/controlC%d", controlnum); -#ifdef CONFIG_SND_GENERIC_DRIVER - platform_driver_unregister(&snd_generic_driver); -#endif snd_info_minor_unregister(); snd_info_done(); if (unregister_chrdev(major, "alsa") != 0) @@ -395,9 +454,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); @@ -415,19 +476,8 @@ EXPORT_SYMBOL(snd_card_register); EXPORT_SYMBOL(snd_component_add); EXPORT_SYMBOL(snd_card_file_add); EXPORT_SYMBOL(snd_card_file_remove); -#ifdef CONFIG_SND_GENERIC_DRIVER -EXPORT_SYMBOL(snd_card_set_generic_dev); -#endif #ifdef CONFIG_PM EXPORT_SYMBOL(snd_power_wait); -EXPORT_SYMBOL(snd_card_set_pm_callback); -#ifdef CONFIG_SND_GENERIC_DRIVER -EXPORT_SYMBOL(snd_card_set_generic_pm_callback); -#endif -#ifdef CONFIG_PCI -EXPORT_SYMBOL(snd_card_pci_suspend); -EXPORT_SYMBOL(snd_card_pci_resume); -#endif #endif /* device.c */ EXPORT_SYMBOL(snd_device_new); diff --git a/sound/core/sound_oss.c b/sound/core/sound_oss.c index e401c670329..d0be32b517c 100644 --- a/sound/core/sound_oss.c +++ b/sound/core/sound_oss.c @@ -35,26 +35,29 @@ #include <sound/info.h> #include <linux/sound.h> -#define SNDRV_OS_MINORS 256 - -static struct list_head snd_oss_minors_hash[SNDRV_CARDS]; +#define SNDRV_OSS_MINORS 128 +static struct snd_minor *snd_oss_minors[SNDRV_OSS_MINORS]; static DECLARE_MUTEX(sound_oss_mutex); -static snd_minor_t *snd_oss_minor_search(int minor) +void *snd_lookup_oss_minor_data(unsigned int minor, int type) { - struct list_head *list; - snd_minor_t *mptr; + struct snd_minor *mreg; + void *private_data; - list_for_each(list, &snd_oss_minors_hash[SNDRV_MINOR_OSS_CARD(minor)]) { - mptr = list_entry(list, snd_minor_t, list); - if (mptr->number == minor) - return mptr; - } - return NULL; + 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, snd_card_t * card, int dev) +static int snd_oss_kernel_minor(int type, struct snd_card *card, int dev) { int minor; @@ -86,30 +89,36 @@ static int snd_oss_kernel_minor(int type, snd_card_t * card, int dev) default: return -EINVAL; } - snd_assert(minor >= 0 && minor < SNDRV_OS_MINORS, return -EINVAL); + snd_assert(minor >= 0 && minor < SNDRV_OSS_MINORS, return -EINVAL); return minor; } -int snd_register_oss_device(int type, snd_card_t * card, int dev, snd_minor_t * reg, const char *name) +int snd_register_oss_device(int type, struct snd_card *card, int dev, + struct file_operations *f_ops, void *private_data, + const char *name) { int minor = snd_oss_kernel_minor(type, card, dev); int minor_unit; - snd_minor_t *preg; + struct snd_minor *preg; int cidx = SNDRV_MINOR_OSS_CARD(minor); int track2 = -1; int register1 = -1, register2 = -1; struct device *carddev = NULL; + if (card && card->number >= 8) + return 0; /* ignore silently */ if (minor < 0) return minor; - preg = (snd_minor_t *)kmalloc(sizeof(snd_minor_t), GFP_KERNEL); + preg = kmalloc(sizeof(struct snd_minor), GFP_KERNEL); if (preg == NULL) return -ENOMEM; - *preg = *reg; - preg->number = minor; + preg->type = type; + preg->card = card ? card->number : -1; preg->device = dev; + preg->f_ops = f_ops; + preg->private_data = private_data; down(&sound_oss_mutex); - list_add_tail(&preg->list, &snd_oss_minors_hash[cidx]); + snd_oss_minors[minor] = preg; minor_unit = SNDRV_MINOR_OSS_DEVICE(minor); switch (minor_unit) { case SNDRV_MINOR_OSS_PCM: @@ -124,13 +133,15 @@ int snd_register_oss_device(int type, snd_card_t * card, int dev, snd_minor_t * } 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; + snd_oss_minors[track2] = preg; } up(&sound_oss_mutex); return 0; @@ -140,23 +151,25 @@ int snd_register_oss_device(int type, snd_card_t * card, int dev, snd_minor_t * unregister_sound_special(register2); if (register1 >= 0) unregister_sound_special(register1); - list_del(&preg->list); + snd_oss_minors[minor] = NULL; up(&sound_oss_mutex); kfree(preg); return -EBUSY; } -int snd_unregister_oss_device(int type, snd_card_t * card, int dev) +int snd_unregister_oss_device(int type, struct snd_card *card, int dev) { int minor = snd_oss_kernel_minor(type, card, dev); int cidx = SNDRV_MINOR_OSS_CARD(minor); int track2 = -1; - snd_minor_t *mptr; + struct snd_minor *mptr; + if (card && card->number >= 8) + return 0; if (minor < 0) return minor; down(&sound_oss_mutex); - mptr = snd_oss_minor_search(minor); + mptr = snd_oss_minors[minor]; if (mptr == NULL) { up(&sound_oss_mutex); return -ENOENT; @@ -173,9 +186,11 @@ int snd_unregister_oss_device(int type, snd_card_t * card, int dev) track2 = SNDRV_MINOR_OSS(cidx, SNDRV_MINOR_OSS_DMMIDI1); break; } - if (track2 >= 0) + if (track2 >= 0) { unregister_sound_special(track2); - list_del(&mptr->list); + snd_oss_minors[track2] = NULL; + } + snd_oss_minors[minor] = NULL; up(&sound_oss_mutex); kfree(mptr); return 0; @@ -187,36 +202,52 @@ int snd_unregister_oss_device(int type, snd_card_t * card, int dev) #ifdef CONFIG_PROC_FS -static snd_info_entry_t *snd_minor_info_oss_entry = NULL; +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(snd_info_entry_t *entry, snd_info_buffer_t * buffer) +static void snd_minor_info_oss_read(struct snd_info_entry *entry, + struct snd_info_buffer *buffer) { - int card, dev; - struct list_head *list; - snd_minor_t *mptr; + int minor; + struct snd_minor *mptr; down(&sound_oss_mutex); - for (card = 0; card < SNDRV_CARDS; card++) { - list_for_each(list, &snd_oss_minors_hash[card]) { - mptr = list_entry(list, snd_minor_t, list); - dev = SNDRV_MINOR_OSS_DEVICE(mptr->number); - 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); - else - snd_iprintf(buffer, "%3i: : %s\n", mptr->number, mptr->comment); - } + for (minor = 0; minor < SNDRV_OSS_MINORS; ++minor) { + if (!(mptr = snd_oss_minors[minor])) + continue; + if (mptr->card >= 0) + snd_iprintf(buffer, "%3i: [%i-%2i]: %s\n", minor, + mptr->card, mptr->device, + snd_oss_device_type_name(mptr->type)); + else + snd_iprintf(buffer, "%3i: : %s\n", minor, + snd_oss_device_type_name(mptr->type)); } up(&sound_oss_mutex); } -#endif /* CONFIG_PROC_FS */ int __init snd_minor_info_oss_init(void) { -#ifdef CONFIG_PROC_FS - snd_info_entry_t *entry; + struct snd_info_entry *entry; entry = snd_info_create_module_entry(THIS_MODULE, "devices", snd_oss_root); if (entry) { @@ -228,26 +259,15 @@ int __init snd_minor_info_oss_init(void) } } snd_minor_info_oss_entry = entry; -#endif return 0; } int __exit snd_minor_info_oss_done(void) { -#ifdef CONFIG_PROC_FS if (snd_minor_info_oss_entry) snd_info_unregister(snd_minor_info_oss_entry); -#endif - return 0; -} - -int __init snd_oss_init_module(void) -{ - int card; - - for (card = 0; card < SNDRV_CARDS; card++) - INIT_LIST_HEAD(&snd_oss_minors_hash[card]); return 0; } +#endif /* CONFIG_PROC_FS */ #endif /* CONFIG_SND_OSSEMUL */ diff --git a/sound/core/timer.c b/sound/core/timer.c index 1b90a38d10f..2425b971b24 100644 --- a/sound/core/timer.c +++ b/sound/core/timer.c @@ -53,8 +53,8 @@ MODULE_LICENSE("GPL"); module_param(timer_limit, int, 0444); MODULE_PARM_DESC(timer_limit, "Maximum global timers in system."); -typedef struct { - snd_timer_instance_t *timeri; +struct snd_timer_user { + struct snd_timer_instance *timeri; int tread; /* enhanced read with timestamps and events */ unsigned long ticks; unsigned long overrun; @@ -62,8 +62,8 @@ typedef struct { int qtail; int qused; int queue_size; - snd_timer_read_t *queue; - snd_timer_tread_t *tqueue; + struct snd_timer_read *queue; + struct snd_timer_tread *tqueue; spinlock_t qlock; unsigned long last_resolution; unsigned int filter; @@ -71,7 +71,7 @@ typedef struct { wait_queue_head_t qchange_sleep; struct fasync_struct *fasync; struct semaphore tread_sem; -} snd_timer_user_t; +}; /* list of timers */ static LIST_HEAD(snd_timer_list); @@ -84,21 +84,21 @@ static DEFINE_SPINLOCK(slave_active_lock); static DECLARE_MUTEX(register_mutex); -static int snd_timer_free(snd_timer_t *timer); -static int snd_timer_dev_free(snd_device_t *device); -static int snd_timer_dev_register(snd_device_t *device); -static int snd_timer_dev_unregister(snd_device_t *device); +static int snd_timer_free(struct snd_timer *timer); +static int snd_timer_dev_free(struct snd_device *device); +static int snd_timer_dev_register(struct snd_device *device); +static int snd_timer_dev_unregister(struct snd_device *device); -static void snd_timer_reschedule(snd_timer_t * timer, unsigned long ticks_left); +static void snd_timer_reschedule(struct snd_timer * timer, unsigned long ticks_left); /* * create a timer instance with the given owner string. * when timer is not NULL, increments the module counter */ -static snd_timer_instance_t *snd_timer_instance_new(char *owner, - snd_timer_t *timer) +static struct snd_timer_instance *snd_timer_instance_new(char *owner, + struct snd_timer *timer) { - snd_timer_instance_t *timeri; + struct snd_timer_instance *timeri; timeri = kzalloc(sizeof(*timeri), GFP_KERNEL); if (timeri == NULL) return NULL; @@ -126,13 +126,13 @@ static snd_timer_instance_t *snd_timer_instance_new(char *owner, /* * find a timer instance from the given timer id */ -static snd_timer_t *snd_timer_find(snd_timer_id_t *tid) +static struct snd_timer *snd_timer_find(struct snd_timer_id *tid) { - snd_timer_t *timer = NULL; + struct snd_timer *timer = NULL; struct list_head *p; list_for_each(p, &snd_timer_list) { - timer = list_entry(p, snd_timer_t, device_list); + timer = list_entry(p, struct snd_timer, device_list); if (timer->tmr_class != tid->dev_class) continue; @@ -152,7 +152,7 @@ static snd_timer_t *snd_timer_find(snd_timer_id_t *tid) #ifdef CONFIG_KMOD -static void snd_timer_request(snd_timer_id_t *tid) +static void snd_timer_request(struct snd_timer_id *tid) { if (! current->fs->root) return; @@ -179,17 +179,17 @@ static void snd_timer_request(snd_timer_id_t *tid) * * call this with register_mutex down. */ -static void snd_timer_check_slave(snd_timer_instance_t *slave) +static void snd_timer_check_slave(struct snd_timer_instance *slave) { - snd_timer_t *timer; - snd_timer_instance_t *master; + struct snd_timer *timer; + struct snd_timer_instance *master; struct list_head *p, *q; /* FIXME: it's really dumb to look up all entries.. */ list_for_each(p, &snd_timer_list) { - timer = list_entry(p, snd_timer_t, device_list); + timer = list_entry(p, struct snd_timer, device_list); list_for_each(q, &timer->open_list_head) { - master = list_entry(q, snd_timer_instance_t, open_list); + master = list_entry(q, struct snd_timer_instance, open_list); if (slave->slave_class == master->slave_class && slave->slave_id == master->slave_id) { list_del(&slave->open_list); @@ -211,14 +211,14 @@ static void snd_timer_check_slave(snd_timer_instance_t *slave) * * call this with register_mutex down. */ -static void snd_timer_check_master(snd_timer_instance_t *master) +static void snd_timer_check_master(struct snd_timer_instance *master) { - snd_timer_instance_t *slave; + struct snd_timer_instance *slave; struct list_head *p, *n; /* check all pending slaves */ list_for_each_safe(p, n, &snd_timer_slave_list) { - slave = list_entry(p, snd_timer_instance_t, open_list); + slave = list_entry(p, struct snd_timer_instance, open_list); if (slave->slave_class == master->slave_class && slave->slave_id == master->slave_id) { list_del(p); @@ -238,12 +238,12 @@ static void snd_timer_check_master(snd_timer_instance_t *master) * open a timer instance * when opening a master, the slave id must be here given. */ -int snd_timer_open(snd_timer_instance_t **ti, - char *owner, snd_timer_id_t *tid, +int snd_timer_open(struct snd_timer_instance **ti, + char *owner, struct snd_timer_id *tid, unsigned int slave_id) { - snd_timer_t *timer; - snd_timer_instance_t *timeri = NULL; + struct snd_timer *timer; + struct snd_timer_instance *timeri = NULL; if (tid->dev_class == SNDRV_TIMER_CLASS_SLAVE) { /* open a slave instance */ @@ -285,7 +285,7 @@ int snd_timer_open(snd_timer_instance_t **ti, } if (!list_empty(&timer->open_list_head)) { timeri = list_entry(timer->open_list_head.next, - snd_timer_instance_t, open_list); + struct snd_timer_instance, open_list); if (timeri->flags & SNDRV_TIMER_IFLG_EXCLUSIVE) { up(®ister_mutex); return -EBUSY; @@ -307,17 +307,17 @@ int snd_timer_open(snd_timer_instance_t **ti, return 0; } -static int _snd_timer_stop(snd_timer_instance_t * timeri, - int keep_flag, enum sndrv_timer_event event); +static int _snd_timer_stop(struct snd_timer_instance *timeri, + int keep_flag, int event); /* * close a timer instance */ -int snd_timer_close(snd_timer_instance_t * timeri) +int snd_timer_close(struct snd_timer_instance *timeri) { - snd_timer_t *timer = NULL; + struct snd_timer *timer = NULL; struct list_head *p, *n; - snd_timer_instance_t *slave; + struct snd_timer_instance *slave; snd_assert(timeri != NULL, return -ENXIO); @@ -353,7 +353,7 @@ int snd_timer_close(snd_timer_instance_t * timeri) timer->hw.close(timer); /* remove slave links */ list_for_each_safe(p, n, &timeri->slave_list_head) { - slave = list_entry(p, snd_timer_instance_t, open_list); + slave = list_entry(p, struct snd_timer_instance, open_list); spin_lock_irq(&slave_active_lock); _snd_timer_stop(slave, 1, SNDRV_TIMER_EVENT_RESOLUTION); list_del(p); @@ -373,9 +373,9 @@ int snd_timer_close(snd_timer_instance_t * timeri) return 0; } -unsigned long snd_timer_resolution(snd_timer_instance_t * timeri) +unsigned long snd_timer_resolution(struct snd_timer_instance *timeri) { - snd_timer_t * timer; + struct snd_timer * timer; if (timeri == NULL) return 0; @@ -387,13 +387,12 @@ unsigned long snd_timer_resolution(snd_timer_instance_t * timeri) return 0; } -static void snd_timer_notify1(snd_timer_instance_t *ti, - enum sndrv_timer_event event) +static void snd_timer_notify1(struct snd_timer_instance *ti, int event) { - snd_timer_t *timer; + struct snd_timer *timer; unsigned long flags; unsigned long resolution = 0; - snd_timer_instance_t *ts; + struct snd_timer_instance *ts; struct list_head *n; struct timespec tstamp; @@ -414,14 +413,14 @@ static void snd_timer_notify1(snd_timer_instance_t *ti, return; spin_lock_irqsave(&timer->lock, flags); list_for_each(n, &ti->slave_active_head) { - ts = list_entry(n, snd_timer_instance_t, active_list); + ts = list_entry(n, struct snd_timer_instance, active_list); if (ts->ccallback) ts->ccallback(ti, event + 100, &tstamp, resolution); } spin_unlock_irqrestore(&timer->lock, flags); } -static int snd_timer_start1(snd_timer_t *timer, snd_timer_instance_t *timeri, +static int snd_timer_start1(struct snd_timer *timer, struct snd_timer_instance *timeri, unsigned long sticks) { list_del(&timeri->active_list); @@ -442,7 +441,7 @@ static int snd_timer_start1(snd_timer_t *timer, snd_timer_instance_t *timeri, } } -static int snd_timer_start_slave(snd_timer_instance_t *timeri) +static int snd_timer_start_slave(struct snd_timer_instance *timeri) { unsigned long flags; @@ -458,9 +457,9 @@ static int snd_timer_start_slave(snd_timer_instance_t *timeri) /* * start the timer instance */ -int snd_timer_start(snd_timer_instance_t * timeri, unsigned int ticks) +int snd_timer_start(struct snd_timer_instance *timeri, unsigned int ticks) { - snd_timer_t *timer; + struct snd_timer *timer; int result = -EINVAL; unsigned long flags; @@ -483,10 +482,10 @@ int snd_timer_start(snd_timer_instance_t * timeri, unsigned int ticks) return result; } -static int _snd_timer_stop(snd_timer_instance_t * timeri, - int keep_flag, enum sndrv_timer_event event) +static int _snd_timer_stop(struct snd_timer_instance * timeri, + int keep_flag, int event) { - snd_timer_t *timer; + struct snd_timer *timer; unsigned long flags; snd_assert(timeri != NULL, return -ENXIO); @@ -532,9 +531,9 @@ static int _snd_timer_stop(snd_timer_instance_t * timeri, * * do not call this from the timer callback! */ -int snd_timer_stop(snd_timer_instance_t * timeri) +int snd_timer_stop(struct snd_timer_instance *timeri) { - snd_timer_t *timer; + struct snd_timer *timer; unsigned long flags; int err; @@ -552,9 +551,9 @@ int snd_timer_stop(snd_timer_instance_t * timeri) /* * start again.. the tick is kept. */ -int snd_timer_continue(snd_timer_instance_t * timeri) +int snd_timer_continue(struct snd_timer_instance *timeri) { - snd_timer_t *timer; + struct snd_timer *timer; int result = -EINVAL; unsigned long flags; @@ -578,7 +577,7 @@ int snd_timer_continue(snd_timer_instance_t * timeri) /* * pause.. remember the ticks left */ -int snd_timer_pause(snd_timer_instance_t * timeri) +int snd_timer_pause(struct snd_timer_instance * timeri) { return _snd_timer_stop(timeri, 0, SNDRV_TIMER_EVENT_PAUSE); } @@ -589,14 +588,14 @@ int snd_timer_pause(snd_timer_instance_t * timeri) * start pending instances and check the scheduling ticks. * when the scheduling ticks is changed set CHANGE flag to reprogram the timer. */ -static void snd_timer_reschedule(snd_timer_t * timer, unsigned long ticks_left) +static void snd_timer_reschedule(struct snd_timer * timer, unsigned long ticks_left) { - snd_timer_instance_t *ti; + struct snd_timer_instance *ti; unsigned long ticks = ~0UL; struct list_head *p; list_for_each(p, &timer->active_list_head) { - ti = list_entry(p, snd_timer_instance_t, active_list); + ti = list_entry(p, struct snd_timer_instance, active_list); if (ti->flags & SNDRV_TIMER_IFLG_START) { ti->flags &= ~SNDRV_TIMER_IFLG_START; ti->flags |= SNDRV_TIMER_IFLG_RUNNING; @@ -624,8 +623,8 @@ static void snd_timer_reschedule(snd_timer_t * timer, unsigned long ticks_left) */ static void snd_timer_tasklet(unsigned long arg) { - snd_timer_t *timer = (snd_timer_t *) arg; - snd_timer_instance_t *ti; + struct snd_timer *timer = (struct snd_timer *) arg; + struct snd_timer_instance *ti; struct list_head *p; unsigned long resolution, ticks; @@ -633,7 +632,7 @@ static void snd_timer_tasklet(unsigned long arg) /* now process all callbacks */ while (!list_empty(&timer->sack_list_head)) { p = timer->sack_list_head.next; /* get first item */ - ti = list_entry(p, snd_timer_instance_t, ack_list); + ti = list_entry(p, struct snd_timer_instance, ack_list); /* remove from ack_list and make empty */ list_del_init(p); @@ -658,17 +657,18 @@ static void snd_timer_tasklet(unsigned long arg) * ticks_left is usually equal to timer->sticks. * */ -void snd_timer_interrupt(snd_timer_t * timer, unsigned long ticks_left) +void snd_timer_interrupt(struct snd_timer * timer, unsigned long ticks_left) { - snd_timer_instance_t *ti, *ts; + struct snd_timer_instance *ti, *ts; unsigned long resolution, ticks; struct list_head *p, *q, *n, *ack_list_head; + unsigned long flags; int use_tasklet = 0; if (timer == NULL) return; - spin_lock(&timer->lock); + spin_lock_irqsave(&timer->lock, flags); /* remember the current resolution */ if (timer->hw.c_resolution) @@ -682,7 +682,7 @@ void snd_timer_interrupt(snd_timer_t * timer, unsigned long ticks_left) * is called. */ list_for_each_safe(p, n, &timer->active_list_head) { - ti = list_entry(p, snd_timer_instance_t, active_list); + ti = list_entry(p, struct snd_timer_instance, active_list); if (!(ti->flags & SNDRV_TIMER_IFLG_RUNNING)) continue; ti->pticks += ticks_left; @@ -708,7 +708,7 @@ void snd_timer_interrupt(snd_timer_t * timer, unsigned long ticks_left) if (list_empty(&ti->ack_list)) list_add_tail(&ti->ack_list, ack_list_head); list_for_each(q, &ti->slave_active_head) { - ts = list_entry(q, snd_timer_instance_t, active_list); + ts = list_entry(q, struct snd_timer_instance, active_list); ts->pticks = ti->pticks; ts->resolution = resolution; if (list_empty(&ts->ack_list)) @@ -735,7 +735,7 @@ void snd_timer_interrupt(snd_timer_t * timer, unsigned long ticks_left) /* now process all fast callbacks */ while (!list_empty(&timer->ack_list_head)) { p = timer->ack_list_head.next; /* get first item */ - ti = list_entry(p, snd_timer_instance_t, ack_list); + ti = list_entry(p, struct snd_timer_instance, ack_list); /* remove from ack_list and make empty */ list_del_init(p); @@ -753,7 +753,7 @@ void snd_timer_interrupt(snd_timer_t * timer, unsigned long ticks_left) /* do we have any slow callbacks? */ use_tasklet = !list_empty(&timer->sack_list_head); - spin_unlock(&timer->lock); + spin_unlock_irqrestore(&timer->lock, flags); if (use_tasklet) tasklet_hi_schedule(&timer->task_queue); @@ -763,12 +763,12 @@ void snd_timer_interrupt(snd_timer_t * timer, unsigned long ticks_left) */ -int snd_timer_new(snd_card_t *card, char *id, snd_timer_id_t *tid, - snd_timer_t **rtimer) +int snd_timer_new(struct snd_card *card, char *id, struct snd_timer_id *tid, + struct snd_timer **rtimer) { - snd_timer_t *timer; + struct snd_timer *timer; int err; - static snd_device_ops_t ops = { + static struct snd_device_ops ops = { .dev_free = snd_timer_dev_free, .dev_register = snd_timer_dev_register, .dev_unregister = snd_timer_dev_unregister @@ -778,8 +778,10 @@ int snd_timer_new(snd_card_t *card, char *id, snd_timer_id_t *tid, snd_assert(rtimer != NULL, return -EINVAL); *rtimer = NULL; timer = kzalloc(sizeof(*timer), GFP_KERNEL); - if (timer == NULL) + if (timer == NULL) { + snd_printk(KERN_ERR "timer: cannot allocate\n"); return -ENOMEM; + } timer->tmr_class = tid->dev_class; timer->card = card; timer->tmr_device = tid->device; @@ -806,7 +808,7 @@ int snd_timer_new(snd_card_t *card, char *id, snd_timer_id_t *tid, return 0; } -static int snd_timer_free(snd_timer_t *timer) +static int snd_timer_free(struct snd_timer *timer) { snd_assert(timer != NULL, return -ENXIO); if (timer->private_free) @@ -815,16 +817,16 @@ static int snd_timer_free(snd_timer_t *timer) return 0; } -static int snd_timer_dev_free(snd_device_t *device) +static int snd_timer_dev_free(struct snd_device *device) { - snd_timer_t *timer = device->device_data; + struct snd_timer *timer = device->device_data; return snd_timer_free(timer); } -static int snd_timer_dev_register(snd_device_t *dev) +static int snd_timer_dev_register(struct snd_device *dev) { - snd_timer_t *timer = dev->device_data; - snd_timer_t *timer1; + struct snd_timer *timer = dev->device_data; + struct snd_timer *timer1; struct list_head *p; snd_assert(timer != NULL && timer->hw.start != NULL && @@ -835,7 +837,7 @@ static int snd_timer_dev_register(snd_device_t *dev) down(®ister_mutex); list_for_each(p, &snd_timer_list) { - timer1 = list_entry(p, snd_timer_t, device_list); + timer1 = list_entry(p, struct snd_timer, device_list); if (timer1->tmr_class > timer->tmr_class) break; if (timer1->tmr_class < timer->tmr_class) @@ -863,10 +865,10 @@ static int snd_timer_dev_register(snd_device_t *dev) return 0; } -static int snd_timer_unregister(snd_timer_t *timer) +static int snd_timer_unregister(struct snd_timer *timer) { struct list_head *p, *n; - snd_timer_instance_t *ti; + struct snd_timer_instance *ti; snd_assert(timer != NULL, return -ENXIO); down(®ister_mutex); @@ -874,7 +876,7 @@ static int snd_timer_unregister(snd_timer_t *timer) snd_printk(KERN_WARNING "timer 0x%lx is busy?\n", (long)timer); list_for_each_safe(p, n, &timer->open_list_head) { list_del_init(p); - ti = list_entry(p, snd_timer_instance_t, open_list); + ti = list_entry(p, struct snd_timer_instance, open_list); ti->timer = NULL; } } @@ -883,18 +885,17 @@ static int snd_timer_unregister(snd_timer_t *timer) return snd_timer_free(timer); } -static int snd_timer_dev_unregister(snd_device_t *device) +static int snd_timer_dev_unregister(struct snd_device *device) { - snd_timer_t *timer = device->device_data; + struct snd_timer *timer = device->device_data; return snd_timer_unregister(timer); } -void snd_timer_notify(snd_timer_t *timer, enum sndrv_timer_event event, - struct timespec *tstamp) +void snd_timer_notify(struct snd_timer *timer, int event, struct timespec *tstamp) { unsigned long flags; unsigned long resolution = 0; - snd_timer_instance_t *ti, *ts; + struct snd_timer_instance *ti, *ts; struct list_head *p, *n; if (! (timer->hw.flags & SNDRV_TIMER_HW_SLAVE)) @@ -911,11 +912,11 @@ void snd_timer_notify(snd_timer_t *timer, enum sndrv_timer_event event, resolution = timer->hw.resolution; } list_for_each(p, &timer->active_list_head) { - ti = list_entry(p, snd_timer_instance_t, active_list); + ti = list_entry(p, struct snd_timer_instance, active_list); if (ti->ccallback) ti->ccallback(ti, event, tstamp, resolution); list_for_each(n, &ti->slave_active_head) { - ts = list_entry(n, snd_timer_instance_t, active_list); + ts = list_entry(n, struct snd_timer_instance, active_list); if (ts->ccallback) ts->ccallback(ts, event, tstamp, resolution); } @@ -926,9 +927,9 @@ void snd_timer_notify(snd_timer_t *timer, enum sndrv_timer_event event, /* * exported functions for global timers */ -int snd_timer_global_new(char *id, int device, snd_timer_t **rtimer) +int snd_timer_global_new(char *id, int device, struct snd_timer **rtimer) { - snd_timer_id_t tid; + struct snd_timer_id tid; tid.dev_class = SNDRV_TIMER_CLASS_GLOBAL; tid.dev_sclass = SNDRV_TIMER_SCLASS_NONE; @@ -938,21 +939,21 @@ int snd_timer_global_new(char *id, int device, snd_timer_t **rtimer) return snd_timer_new(NULL, id, &tid, rtimer); } -int snd_timer_global_free(snd_timer_t *timer) +int snd_timer_global_free(struct snd_timer *timer) { return snd_timer_free(timer); } -int snd_timer_global_register(snd_timer_t *timer) +int snd_timer_global_register(struct snd_timer *timer) { - snd_device_t dev; + struct snd_device dev; memset(&dev, 0, sizeof(dev)); dev.device_data = timer; return snd_timer_dev_register(&dev); } -int snd_timer_global_unregister(snd_timer_t *timer) +int snd_timer_global_unregister(struct snd_timer *timer) { return snd_timer_unregister(timer); } @@ -971,7 +972,7 @@ struct snd_timer_system_private { static void snd_timer_s_function(unsigned long data) { - snd_timer_t *timer = (snd_timer_t *)data; + struct snd_timer *timer = (struct snd_timer *)data; struct snd_timer_system_private *priv = timer->private_data; unsigned long jiff = jiffies; if (time_after(jiff, priv->last_expires)) @@ -979,7 +980,7 @@ static void snd_timer_s_function(unsigned long data) snd_timer_interrupt(timer, (long)jiff - (long)priv->last_jiffies); } -static int snd_timer_s_start(snd_timer_t * timer) +static int snd_timer_s_start(struct snd_timer * timer) { struct snd_timer_system_private *priv; unsigned long njiff; @@ -998,7 +999,7 @@ static int snd_timer_s_start(snd_timer_t * timer) return 0; } -static int snd_timer_s_stop(snd_timer_t * timer) +static int snd_timer_s_stop(struct snd_timer * timer) { struct snd_timer_system_private *priv; unsigned long jiff; @@ -1013,7 +1014,7 @@ static int snd_timer_s_stop(snd_timer_t * timer) return 0; } -static struct _snd_timer_hardware snd_timer_system = +static struct snd_timer_hardware snd_timer_system = { .flags = SNDRV_TIMER_HW_FIRST | SNDRV_TIMER_HW_TASKLET, .resolution = 1000000000L / HZ, @@ -1022,14 +1023,14 @@ static struct _snd_timer_hardware snd_timer_system = .stop = snd_timer_s_stop }; -static void snd_timer_free_system(snd_timer_t *timer) +static void snd_timer_free_system(struct snd_timer *timer) { kfree(timer->private_data); } static int snd_timer_register_system(void) { - snd_timer_t *timer; + struct snd_timer *timer; struct snd_timer_system_private *priv; int err; @@ -1051,21 +1052,22 @@ static int snd_timer_register_system(void) return snd_timer_global_register(timer); } +#ifdef CONFIG_PROC_FS /* * Info interface */ -static void snd_timer_proc_read(snd_info_entry_t *entry, - snd_info_buffer_t * buffer) +static void snd_timer_proc_read(struct snd_info_entry *entry, + struct snd_info_buffer *buffer) { unsigned long flags; - snd_timer_t *timer; - snd_timer_instance_t *ti; + struct snd_timer *timer; + struct snd_timer_instance *ti; struct list_head *p, *q; down(®ister_mutex); list_for_each(p, &snd_timer_list) { - timer = list_entry(p, snd_timer_t, device_list); + timer = list_entry(p, struct snd_timer, device_list); switch (timer->tmr_class) { case SNDRV_TIMER_CLASS_GLOBAL: snd_iprintf(buffer, "G%i: ", timer->tmr_device); @@ -1094,7 +1096,7 @@ static void snd_timer_proc_read(snd_info_entry_t *entry, snd_iprintf(buffer, "\n"); spin_lock_irqsave(&timer->lock, flags); list_for_each(q, &timer->open_list_head) { - ti = list_entry(q, snd_timer_instance_t, open_list); + ti = list_entry(q, struct snd_timer_instance, open_list); snd_iprintf(buffer, " Client %s : %s\n", ti->owner ? ti->owner : "unknown", ti->flags & (SNDRV_TIMER_IFLG_START | @@ -1106,16 +1108,43 @@ static void snd_timer_proc_read(snd_info_entry_t *entry, up(®ister_mutex); } +static struct snd_info_entry *snd_timer_proc_entry = NULL; + +static void __init snd_timer_proc_init(void) +{ + struct snd_info_entry *entry; + + entry = snd_info_create_module_entry(THIS_MODULE, "timers", NULL); + if (entry != NULL) { + entry->c.text.read_size = SNDRV_TIMER_DEVICES * 128; + entry->c.text.read = snd_timer_proc_read; + if (snd_info_register(entry) < 0) { + snd_info_free_entry(entry); + entry = NULL; + } + } + snd_timer_proc_entry = entry; +} + +static void __exit snd_timer_proc_done(void) +{ + snd_info_unregister(snd_timer_proc_entry); +} +#else /* !CONFIG_PROC_FS */ +#define snd_timer_proc_init() +#define snd_timer_proc_done() +#endif + /* * USER SPACE interface */ -static void snd_timer_user_interrupt(snd_timer_instance_t *timeri, +static void snd_timer_user_interrupt(struct snd_timer_instance *timeri, unsigned long resolution, unsigned long ticks) { - snd_timer_user_t *tu = timeri->callback_data; - snd_timer_read_t *r; + struct snd_timer_user *tu = timeri->callback_data; + struct snd_timer_read *r; int prev; spin_lock(&tu->qlock); @@ -1142,8 +1171,8 @@ static void snd_timer_user_interrupt(snd_timer_instance_t *timeri, wake_up(&tu->qchange_sleep); } -static void snd_timer_user_append_to_tqueue(snd_timer_user_t *tu, - snd_timer_tread_t *tread) +static void snd_timer_user_append_to_tqueue(struct snd_timer_user *tu, + struct snd_timer_tread *tread) { if (tu->qused >= tu->queue_size) { tu->overrun++; @@ -1154,13 +1183,13 @@ static void snd_timer_user_append_to_tqueue(snd_timer_user_t *tu, } } -static void snd_timer_user_ccallback(snd_timer_instance_t *timeri, - enum sndrv_timer_event event, +static void snd_timer_user_ccallback(struct snd_timer_instance *timeri, + int event, struct timespec *tstamp, unsigned long resolution) { - snd_timer_user_t *tu = timeri->callback_data; - snd_timer_tread_t r1; + struct snd_timer_user *tu = timeri->callback_data; + struct snd_timer_tread r1; if (event >= SNDRV_TIMER_EVENT_START && event <= SNDRV_TIMER_EVENT_PAUSE) @@ -1177,12 +1206,12 @@ static void snd_timer_user_ccallback(snd_timer_instance_t *timeri, wake_up(&tu->qchange_sleep); } -static void snd_timer_user_tinterrupt(snd_timer_instance_t *timeri, +static void snd_timer_user_tinterrupt(struct snd_timer_instance *timeri, unsigned long resolution, unsigned long ticks) { - snd_timer_user_t *tu = timeri->callback_data; - snd_timer_tread_t *r, r1; + struct snd_timer_user *tu = timeri->callback_data; + struct snd_timer_tread *r, r1; struct timespec tstamp; int prev, append = 0; @@ -1233,7 +1262,7 @@ static void snd_timer_user_tinterrupt(snd_timer_instance_t *timeri, static int snd_timer_user_open(struct inode *inode, struct file *file) { - snd_timer_user_t *tu; + struct snd_timer_user *tu; tu = kzalloc(sizeof(*tu), GFP_KERNEL); if (tu == NULL) @@ -1243,7 +1272,7 @@ static int snd_timer_user_open(struct inode *inode, struct file *file) init_MUTEX(&tu->tread_sem); tu->ticks = 1; tu->queue_size = 128; - tu->queue = kmalloc(tu->queue_size * sizeof(snd_timer_read_t), + tu->queue = kmalloc(tu->queue_size * sizeof(struct snd_timer_read), GFP_KERNEL); if (tu->queue == NULL) { kfree(tu); @@ -1255,7 +1284,7 @@ static int snd_timer_user_open(struct inode *inode, struct file *file) static int snd_timer_user_release(struct inode *inode, struct file *file) { - snd_timer_user_t *tu; + struct snd_timer_user *tu; if (file->private_data) { tu = file->private_data; @@ -1270,7 +1299,7 @@ static int snd_timer_user_release(struct inode *inode, struct file *file) return 0; } -static void snd_timer_user_zero_id(snd_timer_id_t *id) +static void snd_timer_user_zero_id(struct snd_timer_id *id) { id->dev_class = SNDRV_TIMER_CLASS_NONE; id->dev_sclass = SNDRV_TIMER_SCLASS_NONE; @@ -1279,7 +1308,7 @@ static void snd_timer_user_zero_id(snd_timer_id_t *id) id->subdevice = -1; } -static void snd_timer_user_copy_id(snd_timer_id_t *id, snd_timer_t *timer) +static void snd_timer_user_copy_id(struct snd_timer_id *id, struct snd_timer *timer) { id->dev_class = timer->tmr_class; id->dev_sclass = SNDRV_TIMER_SCLASS_NONE; @@ -1288,10 +1317,10 @@ static void snd_timer_user_copy_id(snd_timer_id_t *id, snd_timer_t *timer) id->subdevice = timer->tmr_subdevice; } -static int snd_timer_user_next_device(snd_timer_id_t __user *_tid) +static int snd_timer_user_next_device(struct snd_timer_id __user *_tid) { - snd_timer_id_t id; - snd_timer_t *timer; + struct snd_timer_id id; + struct snd_timer *timer; struct list_head *p; if (copy_from_user(&id, _tid, sizeof(id))) @@ -1302,7 +1331,7 @@ static int snd_timer_user_next_device(snd_timer_id_t __user *_tid) snd_timer_user_zero_id(&id); else { timer = list_entry(snd_timer_list.next, - snd_timer_t, device_list); + struct snd_timer, device_list); snd_timer_user_copy_id(&id, timer); } } else { @@ -1310,7 +1339,7 @@ static int snd_timer_user_next_device(snd_timer_id_t __user *_tid) case SNDRV_TIMER_CLASS_GLOBAL: id.device = id.device < 0 ? 0 : id.device + 1; list_for_each(p, &snd_timer_list) { - timer = list_entry(p, snd_timer_t, device_list); + timer = list_entry(p, struct snd_timer, device_list); if (timer->tmr_class > SNDRV_TIMER_CLASS_GLOBAL) { snd_timer_user_copy_id(&id, timer); break; @@ -1343,7 +1372,7 @@ static int snd_timer_user_next_device(snd_timer_id_t __user *_tid) } } list_for_each(p, &snd_timer_list) { - timer = list_entry(p, snd_timer_t, device_list); + timer = list_entry(p, struct snd_timer, device_list); if (timer->tmr_class > id.dev_class) { snd_timer_user_copy_id(&id, timer); break; @@ -1385,11 +1414,11 @@ static int snd_timer_user_next_device(snd_timer_id_t __user *_tid) } static int snd_timer_user_ginfo(struct file *file, - snd_timer_ginfo_t __user *_ginfo) + struct snd_timer_ginfo __user *_ginfo) { - snd_timer_ginfo_t *ginfo; - snd_timer_id_t tid; - snd_timer_t *t; + struct snd_timer_ginfo *ginfo; + struct snd_timer_id tid; + struct snd_timer *t; struct list_head *p; int err = 0; @@ -1430,10 +1459,10 @@ static int snd_timer_user_ginfo(struct file *file, } static int snd_timer_user_gparams(struct file *file, - snd_timer_gparams_t __user *_gparams) + struct snd_timer_gparams __user *_gparams) { - snd_timer_gparams_t gparams; - snd_timer_t *t; + struct snd_timer_gparams gparams; + struct snd_timer *t; int err; if (copy_from_user(&gparams, _gparams, sizeof(gparams))) @@ -1459,11 +1488,11 @@ _error: } static int snd_timer_user_gstatus(struct file *file, - snd_timer_gstatus_t __user *_gstatus) + struct snd_timer_gstatus __user *_gstatus) { - snd_timer_gstatus_t gstatus; - snd_timer_id_t tid; - snd_timer_t *t; + struct snd_timer_gstatus gstatus; + struct snd_timer_id tid; + struct snd_timer *t; int err = 0; if (copy_from_user(&gstatus, _gstatus, sizeof(gstatus))) @@ -1495,10 +1524,10 @@ static int snd_timer_user_gstatus(struct file *file, } static int snd_timer_user_tselect(struct file *file, - snd_timer_select_t __user *_tselect) + struct snd_timer_select __user *_tselect) { - snd_timer_user_t *tu; - snd_timer_select_t tselect; + struct snd_timer_user *tu; + struct snd_timer_select tselect; char str[32]; int err = 0; @@ -1524,12 +1553,12 @@ static int snd_timer_user_tselect(struct file *file, kfree(tu->tqueue); tu->tqueue = NULL; if (tu->tread) { - tu->tqueue = kmalloc(tu->queue_size * sizeof(snd_timer_tread_t), + tu->tqueue = kmalloc(tu->queue_size * sizeof(struct snd_timer_tread), GFP_KERNEL); if (tu->tqueue == NULL) err = -ENOMEM; } else { - tu->queue = kmalloc(tu->queue_size * sizeof(snd_timer_read_t), + tu->queue = kmalloc(tu->queue_size * sizeof(struct snd_timer_read), GFP_KERNEL); if (tu->queue == NULL) err = -ENOMEM; @@ -1552,11 +1581,11 @@ static int snd_timer_user_tselect(struct file *file, } static int snd_timer_user_info(struct file *file, - snd_timer_info_t __user *_info) + struct snd_timer_info __user *_info) { - snd_timer_user_t *tu; - snd_timer_info_t *info; - snd_timer_t *t; + struct snd_timer_user *tu; + struct snd_timer_info *info; + struct snd_timer *t; int err = 0; tu = file->private_data; @@ -1580,13 +1609,13 @@ static int snd_timer_user_info(struct file *file, } static int snd_timer_user_params(struct file *file, - snd_timer_params_t __user *_params) + struct snd_timer_params __user *_params) { - snd_timer_user_t *tu; - snd_timer_params_t params; - snd_timer_t *t; - snd_timer_read_t *tr; - snd_timer_tread_t *ttr; + struct snd_timer_user *tu; + struct snd_timer_params params; + struct snd_timer *t; + struct snd_timer_read *tr; + struct snd_timer_tread *ttr; int err; tu = file->private_data; @@ -1656,14 +1685,14 @@ static int snd_timer_user_params(struct file *file, tu->qhead = tu->qtail = tu->qused = 0; if (tu->timeri->flags & SNDRV_TIMER_IFLG_EARLY_EVENT) { if (tu->tread) { - snd_timer_tread_t tread; + struct snd_timer_tread tread; tread.event = SNDRV_TIMER_EVENT_EARLY; tread.tstamp.tv_sec = 0; tread.tstamp.tv_nsec = 0; tread.val = 0; snd_timer_user_append_to_tqueue(tu, &tread); } else { - snd_timer_read_t *r = &tu->queue[0]; + struct snd_timer_read *r = &tu->queue[0]; r->resolution = 0; r->ticks = 0; tu->qused++; @@ -1680,10 +1709,10 @@ static int snd_timer_user_params(struct file *file, } static int snd_timer_user_status(struct file *file, - snd_timer_status_t __user *_status) + struct snd_timer_status __user *_status) { - snd_timer_user_t *tu; - snd_timer_status_t status; + struct snd_timer_user *tu; + struct snd_timer_status status; tu = file->private_data; snd_assert(tu->timeri != NULL, return -ENXIO); @@ -1703,7 +1732,7 @@ static int snd_timer_user_status(struct file *file, static int snd_timer_user_start(struct file *file) { int err; - snd_timer_user_t *tu; + struct snd_timer_user *tu; tu = file->private_data; snd_assert(tu->timeri != NULL, return -ENXIO); @@ -1716,7 +1745,7 @@ static int snd_timer_user_start(struct file *file) static int snd_timer_user_stop(struct file *file) { int err; - snd_timer_user_t *tu; + struct snd_timer_user *tu; tu = file->private_data; snd_assert(tu->timeri != NULL, return -ENXIO); @@ -1726,7 +1755,7 @@ static int snd_timer_user_stop(struct file *file) static int snd_timer_user_continue(struct file *file) { int err; - snd_timer_user_t *tu; + struct snd_timer_user *tu; tu = file->private_data; snd_assert(tu->timeri != NULL, return -ENXIO); @@ -1737,7 +1766,7 @@ static int snd_timer_user_continue(struct file *file) static int snd_timer_user_pause(struct file *file) { int err; - snd_timer_user_t *tu; + struct snd_timer_user *tu; tu = file->private_data; snd_assert(tu->timeri != NULL, return -ENXIO); @@ -1754,7 +1783,7 @@ enum { static long snd_timer_user_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { - snd_timer_user_t *tu; + struct snd_timer_user *tu; void __user *argp = (void __user *)arg; int __user *p = argp; @@ -1813,7 +1842,7 @@ static long snd_timer_user_ioctl(struct file *file, unsigned int cmd, static int snd_timer_user_fasync(int fd, struct file * file, int on) { - snd_timer_user_t *tu; + struct snd_timer_user *tu; int err; tu = file->private_data; @@ -1826,12 +1855,12 @@ static int snd_timer_user_fasync(int fd, struct file * file, int on) static ssize_t snd_timer_user_read(struct file *file, char __user *buffer, size_t count, loff_t *offset) { - snd_timer_user_t *tu; + struct snd_timer_user *tu; long result = 0, unit; int err = 0; tu = file->private_data; - unit = tu->tread ? sizeof(snd_timer_tread_t) : sizeof(snd_timer_read_t); + unit = tu->tread ? sizeof(struct snd_timer_tread) : sizeof(struct snd_timer_read); spin_lock_irq(&tu->qlock); while ((long)count - result >= unit) { while (!tu->qused) { @@ -1864,13 +1893,13 @@ static ssize_t snd_timer_user_read(struct file *file, char __user *buffer, if (tu->tread) { if (copy_to_user(buffer, &tu->tqueue[tu->qhead++], - sizeof(snd_timer_tread_t))) { + sizeof(struct snd_timer_tread))) { err = -EFAULT; goto _error; } } else { if (copy_to_user(buffer, &tu->queue[tu->qhead++], - sizeof(snd_timer_read_t))) { + sizeof(struct snd_timer_read))) { err = -EFAULT; goto _error; } @@ -1892,7 +1921,7 @@ static ssize_t snd_timer_user_read(struct file *file, char __user *buffer, static unsigned int snd_timer_user_poll(struct file *file, poll_table * wait) { unsigned int mask; - snd_timer_user_t *tu; + struct snd_timer_user *tu; tu = file->private_data; @@ -1923,44 +1952,27 @@ static struct file_operations snd_timer_f_ops = .fasync = snd_timer_user_fasync, }; -static snd_minor_t snd_timer_reg = -{ - .comment = "timer", - .f_ops = &snd_timer_f_ops, -}; - /* * ENTRY functions */ -static snd_info_entry_t *snd_timer_proc_entry = NULL; - static int __init alsa_timer_init(void) { int err; - snd_info_entry_t *entry; #ifdef SNDRV_OSS_INFO_DEV_TIMERS snd_oss_info_register(SNDRV_OSS_INFO_DEV_TIMERS, SNDRV_CARDS - 1, "system timer"); #endif - entry = snd_info_create_module_entry(THIS_MODULE, "timers", NULL); - if (entry != NULL) { - entry->c.text.read_size = SNDRV_TIMER_DEVICES * 128; - entry->c.text.read = snd_timer_proc_read; - if (snd_info_register(entry) < 0) { - snd_info_free_entry(entry); - entry = NULL; - } - } - snd_timer_proc_entry = entry; + 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_reg, "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); + snd_timer_proc_init(); return 0; } @@ -1971,13 +1983,10 @@ static void __exit alsa_timer_exit(void) snd_unregister_device(SNDRV_DEVICE_TYPE_TIMER, NULL, 0); /* unregister the system timer */ list_for_each_safe(p, n, &snd_timer_list) { - snd_timer_t *timer = list_entry(p, snd_timer_t, device_list); + struct snd_timer *timer = list_entry(p, struct snd_timer, device_list); snd_timer_unregister(timer); } - if (snd_timer_proc_entry) { - snd_info_unregister(snd_timer_proc_entry); - snd_timer_proc_entry = NULL; - } + snd_timer_proc_done(); #ifdef SNDRV_OSS_INFO_DEV_TIMERS snd_oss_info_unregister(SNDRV_OSS_INFO_DEV_TIMERS, SNDRV_CARDS - 1); #endif diff --git a/sound/core/timer_compat.c b/sound/core/timer_compat.c index 3de552dfe80..5512f5373c5 100644 --- a/sound/core/timer_compat.c +++ b/sound/core/timer_compat.c @@ -22,7 +22,7 @@ #include <linux/compat.h> -struct sndrv_timer_info32 { +struct snd_timer_info32 { u32 flags; s32 card; unsigned char id[64]; @@ -33,11 +33,11 @@ struct sndrv_timer_info32 { }; static int snd_timer_user_info_compat(struct file *file, - struct sndrv_timer_info32 __user *_info) + struct snd_timer_info32 __user *_info) { - snd_timer_user_t *tu; - struct sndrv_timer_info32 info; - snd_timer_t *t; + struct snd_timer_user *tu; + struct snd_timer_info32 info; + struct snd_timer *t; tu = file->private_data; snd_assert(tu->timeri != NULL, return -ENXIO); @@ -55,7 +55,7 @@ static int snd_timer_user_info_compat(struct file *file, return 0; } -struct sndrv_timer_status32 { +struct snd_timer_status32 { struct compat_timespec tstamp; u32 resolution; u32 lost; @@ -65,10 +65,10 @@ struct sndrv_timer_status32 { }; static int snd_timer_user_status_compat(struct file *file, - struct sndrv_timer_status32 __user *_status) + struct snd_timer_status32 __user *_status) { - snd_timer_user_t *tu; - snd_timer_status_t status; + struct snd_timer_user *tu; + struct snd_timer_status status; tu = file->private_data; snd_assert(tu->timeri != NULL, return -ENXIO); @@ -89,8 +89,8 @@ static int snd_timer_user_status_compat(struct file *file, */ enum { - SNDRV_TIMER_IOCTL_INFO32 = _IOR('T', 0x11, struct sndrv_timer_info32), - SNDRV_TIMER_IOCTL_STATUS32 = _IOW('T', 0x14, struct sndrv_timer_status32), + SNDRV_TIMER_IOCTL_INFO32 = _IOR('T', 0x11, struct snd_timer_info32), + SNDRV_TIMER_IOCTL_STATUS32 = _IOW('T', 0x14, struct snd_timer_status32), }; static long snd_timer_user_ioctl_compat(struct file *file, unsigned int cmd, unsigned long arg) |