X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=sound%2Fcore%2Finfo.c;h=2582b74d319953ebd0cb95d46f36d7e044e520fe;hb=43bc926fffd92024b46cafaf7350d669ba9ca884;hp=fadd47112e65e30e1b4a0a8efcb3f9dd9870f4b8;hpb=5273a3df6485dc2ad6aa7ddd441b9a21970f003b;p=linux-2.6.git diff --git a/sound/core/info.c b/sound/core/info.c index fadd47112..2582b74d3 100644 --- a/sound/core/info.c +++ b/sound/core/info.c @@ -20,23 +20,26 @@ */ #include -#include #include #include #include #include +#include #include #include #include #include #include #include +#include #include /* * */ +#ifdef CONFIG_PROC_FS + int snd_info_check_reserved_words(const char *str) { static char *reserved[] = @@ -66,16 +69,14 @@ int snd_info_check_reserved_words(const char *str) return 1; } -#ifdef CONFIG_PROC_FS +static DEFINE_MUTEX(info_mutex); -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,22 +91,21 @@ 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 res; - char sbuffer[512]; + int len, res; if (buffer->stop || buffer->error) return 0; + len = buffer->len - buffer->size; va_start(args, fmt); - res = vscnprintf(sbuffer, sizeof(sbuffer), fmt, args); + res = vsnprintf(buffer->curr, len, fmt, args); va_end(args); - if (buffer->size + res >= buffer->len) { + if (res >= len) { buffer->stop = 1; return 0; } - strcpy(buffer->curr, sbuffer); buffer->curr += res; buffer->size += res; return res; @@ -116,9 +116,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) @@ -126,8 +126,8 @@ static inline void snd_info_entry_prepare(struct proc_dir_entry *de) de->owner = THIS_MODULE; } -void snd_remove_proc_entry(struct proc_dir_entry *parent, - struct proc_dir_entry *de) +static void snd_remove_proc_entry(struct proc_dir_entry *parent, + struct proc_dir_entry *de) { if (de) remove_proc_entry(de->name, parent); @@ -135,11 +135,11 @@ 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; - data = snd_magic_cast(snd_info_private_data_t, file->private_data, return -ENXIO); + data = file->private_data; entry = data->entry; lock_kernel(); switch (entry->content) { @@ -174,91 +174,103 @@ out: return ret; } -static ssize_t snd_info_entry_read(struct file *file, char *buffer, +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; - data = snd_magic_cast(snd_info_private_data_t, file->private_data, return -ENXIO); + data = file->private_data; snd_assert(data != NULL, return -ENXIO); + pos = *offset; + if (pos < 0 || (long) pos != pos || (ssize_t) count < 0) + return -EIO; + if ((unsigned long) pos + (unsigned long) count < (unsigned long) pos) + return -EIO; entry = data->entry; switch (entry->content) { case SNDRV_INFO_CONTENT_TEXT: buf = data->rbuffer; if (buf == NULL) return -EIO; - if (file->f_pos >= (long)buf->size) + if (pos >= buf->size) return 0; - size = buf->size - file->f_pos; + size = buf->size - pos; size = min(count, size); - if (copy_to_user(buffer, buf->buffer + file->f_pos, size)) + if (copy_to_user(buffer, buf->buffer + pos, size)) return -EFAULT; - file->f_pos += size; break; case SNDRV_INFO_CONTENT_DATA: if (entry->c.ops->read) - return entry->c.ops->read(entry, + size = entry->c.ops->read(entry, data->file_private_data, - file, buffer, count); + file, buffer, count, pos); break; } + if ((ssize_t) size > 0) + *offset = pos + size; return size; } -static ssize_t snd_info_entry_write(struct file *file, const char *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; - data = snd_magic_cast(snd_info_private_data_t, file->private_data, return -ENXIO); + data = file->private_data; snd_assert(data != NULL, return -ENXIO); entry = data->entry; + pos = *offset; + if (pos < 0 || (long) pos != pos || (ssize_t) count < 0) + return -EIO; + if ((unsigned long) pos + (unsigned long) count < (unsigned long) pos) + return -EIO; switch (entry->content) { case SNDRV_INFO_CONTENT_TEXT: buf = data->wbuffer; if (buf == NULL) return -EIO; - if (file->f_pos < 0) - return -EINVAL; - if (file->f_pos >= (long)buf->len) + if (pos >= buf->len) return -ENOMEM; - size = buf->len - file->f_pos; + size = buf->len - pos; size = min(count, size); - if (copy_from_user(buf->buffer + file->f_pos, buffer, size)) + if (copy_from_user(buf->buffer + pos, buffer, size)) return -EFAULT; - if ((long)buf->size < file->f_pos + size) - buf->size = file->f_pos + size; - file->f_pos += size; + if ((long)buf->size < pos + size) + buf->size = pos + size; break; case SNDRV_INFO_CONTENT_DATA: if (entry->c.ops->write) - return entry->c.ops->write(entry, + size = entry->c.ops->write(entry, data->file_private_data, - file, buffer, count); + file, buffer, count, pos); break; } + if ((ssize_t) size > 0) + *offset = pos + size; return size; } 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); + mutex_lock(&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); + mutex_unlock(&info_mutex); return -ENODEV; } if (!try_module_get(entry->module)) { @@ -284,7 +296,7 @@ static int snd_info_entry_open(struct inode *inode, struct file *file) goto __error; } } - data = snd_magic_kcalloc(snd_info_private_data_t, 0, GFP_KERNEL); + data = kzalloc(sizeof(*data), GFP_KERNEL); if (data == NULL) { err = -ENOMEM; goto __error; @@ -293,10 +305,9 @@ static int snd_info_entry_open(struct inode *inode, struct file *file) switch (entry->content) { case SNDRV_INFO_CONTENT_TEXT: if (mode == O_RDONLY || mode == O_RDWR) { - buffer = (snd_info_buffer_t *) - snd_kcalloc(sizeof(snd_info_buffer_t), GFP_KERNEL); + buffer = kzalloc(sizeof(*buffer), GFP_KERNEL); if (buffer == NULL) { - snd_magic_kfree(data); + kfree(data); err = -ENOMEM; goto __error; } @@ -305,7 +316,7 @@ static int snd_info_entry_open(struct inode *inode, struct file *file) buffer->buffer = vmalloc(buffer->len); if (buffer->buffer == NULL) { kfree(buffer); - snd_magic_kfree(data); + kfree(data); err = -ENOMEM; goto __error; } @@ -313,14 +324,13 @@ static int snd_info_entry_open(struct inode *inode, struct file *file) data->rbuffer = buffer; } if (mode == O_WRONLY || mode == O_RDWR) { - buffer = (snd_info_buffer_t *) - snd_kcalloc(sizeof(snd_info_buffer_t), GFP_KERNEL); + buffer = kzalloc(sizeof(*buffer), GFP_KERNEL); if (buffer == NULL) { if (mode == O_RDWR) { vfree(data->rbuffer->buffer); kfree(data->rbuffer); } - snd_magic_kfree(data); + kfree(data); err = -ENOMEM; goto __error; } @@ -333,7 +343,7 @@ static int snd_info_entry_open(struct inode *inode, struct file *file) kfree(data->rbuffer); } kfree(buffer); - snd_magic_kfree(data); + kfree(data); err = -ENOMEM; goto __error; } @@ -345,20 +355,20 @@ static int snd_info_entry_open(struct inode *inode, struct file *file) if (entry->c.ops->open) { if ((err = entry->c.ops->open(entry, mode, &data->file_private_data)) < 0) { - snd_magic_kfree(data); + kfree(data); goto __error; } } break; } file->private_data = data; - up(&info_mutex); + mutex_unlock(&info_mutex); if (entry->content == SNDRV_INFO_CONTENT_TEXT && (mode == O_RDONLY || mode == O_RDWR)) { if (entry->c.text.read) { - down(&entry->access); + mutex_lock(&entry->access); entry->c.text.read(entry, data->rbuffer); - up(&entry->access); + mutex_unlock(&entry->access); } } return 0; @@ -366,18 +376,18 @@ static int snd_info_entry_open(struct inode *inode, struct file *file) __error: module_put(entry->module); __error1: - up(&info_mutex); + mutex_unlock(&info_mutex); return err; } 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; - data = snd_magic_cast(snd_info_private_data_t, file->private_data, return -ENXIO); + data = file->private_data; entry = data->entry; switch (entry->content) { case SNDRV_INFO_CONTENT_TEXT: @@ -405,17 +415,17 @@ static int snd_info_entry_release(struct inode *inode, struct file *file) break; } module_put(entry->module); - snd_magic_kfree(data); + kfree(data); return 0; } 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; - data = snd_magic_cast(snd_info_private_data_t, file->private_data, return -ENXIO); + data = file->private_data; if (data == NULL) return 0; entry = data->entry; @@ -435,13 +445,13 @@ static unsigned int snd_info_entry_poll(struct file *file, poll_table * wait) return mask; } -static int snd_info_entry_ioctl(struct inode *inode, struct file *file, - unsigned int cmd, unsigned long arg) +static long snd_info_entry_ioctl(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 = snd_magic_cast(snd_info_private_data_t, file->private_data, return -ENXIO); + data = file->private_data; if (data == NULL) return 0; entry = data->entry; @@ -459,10 +469,10 @@ 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 = snd_magic_cast(snd_info_private_data_t, file->private_data, return -ENXIO); + data = file->private_data; if (data == NULL) return 0; entry = data->entry; @@ -479,15 +489,15 @@ static int snd_info_entry_mmap(struct file *file, struct vm_area_struct *vma) static struct file_operations snd_info_entry_operations = { - .owner = THIS_MODULE, - .llseek = snd_info_entry_llseek, - .read = snd_info_entry_read, - .write = snd_info_entry_write, - .poll = snd_info_entry_poll, - .ioctl = snd_info_entry_ioctl, - .mmap = snd_info_entry_mmap, - .open = snd_info_entry_open, - .release = snd_info_entry_release, + .owner = THIS_MODULE, + .llseek = snd_info_entry_llseek, + .read = snd_info_entry_read, + .write = snd_info_entry_write, + .poll = snd_info_entry_poll, + .unlocked_ioctl = snd_info_entry_ioctl, + .mmap = snd_info_entry_mmap, + .open = snd_info_entry_open, + .release = snd_info_entry_release, }; /** @@ -501,8 +511,8 @@ static struct file_operations snd_info_entry_operations = * * Returns the pointer of new instance or NULL on failure. */ -struct proc_dir_entry *snd_create_proc_entry(const char *name, mode_t mode, - struct proc_dir_entry *parent) +static struct proc_dir_entry *snd_create_proc_entry(const char *name, mode_t mode, + struct proc_dir_entry *parent) { struct proc_dir_entry *p; p = create_proc_entry(name, mode, parent); @@ -521,7 +531,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; @@ -534,7 +544,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; @@ -546,7 +556,6 @@ int __init snd_info_init(void) } #endif snd_info_version_init(); - snd_memory_info_init(); snd_minor_info_init(); snd_minor_info_oss_init(); snd_card_info_init(); @@ -558,16 +567,13 @@ int __exit snd_info_done(void) snd_card_info_done(); snd_minor_info_oss_done(); snd_minor_info_done(); - snd_memory_info_done(); 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); } @@ -583,10 +589,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); @@ -606,7 +612,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; @@ -626,7 +632,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) { @@ -651,7 +657,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; @@ -682,7 +688,7 @@ int snd_info_get_line(snd_info_buffer_t * buffer, char *line, int len) } /** - * snd_info_get_line - parse a string token + * snd_info_get_str - parse a string token * @dest: the buffer to store the string token * @src: the original string * @len: the max. length of token - 1 @@ -729,20 +735,20 @@ 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; - entry = snd_magic_kcalloc(snd_info_entry_t, 0, GFP_KERNEL); + struct snd_info_entry *entry; + entry = kzalloc(sizeof(*entry), GFP_KERNEL); if (entry == NULL) return NULL; - entry->name = snd_kmalloc_strdup(name, GFP_KERNEL); + entry->name = kstrdup(name, GFP_KERNEL); if (entry->name == NULL) { - snd_magic_kfree(entry); + kfree(entry); return NULL; } entry->mode = S_IFREG | S_IRUGO; entry->content = SNDRV_INFO_CONTENT_TEXT; - init_MUTEX(&entry->access); + mutex_init(&entry->access); return entry; } @@ -756,11 +762,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; @@ -778,11 +784,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; @@ -791,29 +797,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 = snd_magic_cast(snd_info_entry_t, device->device_data, return -ENXIO); + 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 = snd_magic_cast(snd_info_entry_t, device->device_data, return -ENXIO); + 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 = snd_magic_cast(snd_info_entry_t, device->device_data, return -ENXIO); + 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 = snd_magic_cast(snd_info_entry_t, device->device_data, return -ENXIO); + struct snd_info_entry *entry = device->device_data; return snd_info_unregister(entry); } @@ -837,16 +843,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); @@ -867,15 +873,14 @@ 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; - if (entry->name) - kfree((char *)entry->name); + kfree(entry->name); if (entry->private_free) entry->private_free(entry); - snd_magic_kfree(entry); + kfree(entry); } /** @@ -886,16 +891,16 @@ 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; snd_assert(entry != NULL, return -ENXIO); root = entry->parent == NULL ? snd_proc_root : entry->parent->p; - down(&info_mutex); + mutex_lock(&info_mutex); p = snd_create_proc_entry(entry->name, entry->mode, root); if (!p) { - up(&info_mutex); + mutex_unlock(&info_mutex); return -ENOMEM; } p->owner = entry->module; @@ -904,7 +909,7 @@ int snd_info_register(snd_info_entry_t * entry) p->size = entry->size; p->data = entry; entry->p = p; - up(&info_mutex); + mutex_unlock(&info_mutex); return 0; } @@ -916,16 +921,18 @@ 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 && entry->p != 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); - down(&info_mutex); + mutex_lock(&info_mutex); snd_remove_proc_entry(root, entry->p); - up(&info_mutex); + mutex_unlock(&info_mutex); snd_info_free_entry(entry); return 0; } @@ -934,27 +941,19 @@ 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) { - static char *kernel_version = UTS_RELEASE; - snd_iprintf(buffer, - "Advanced Linux Sound Architecture Driver Version " CONFIG_SND_VERSION CONFIG_SND_DATE ".\n" - "Compiled on " __DATE__ " for kernel %s" -#ifdef CONFIG_SMP - " (SMP)" -#endif -#ifdef MODVERSIONS - " with versioned symbols" -#endif - ".\n", kernel_version); + "Advanced Linux Sound Architecture Driver Version " + CONFIG_SND_VERSION CONFIG_SND_DATE ".\n" + ); } 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)