2 * Information interface for ALSA driver
3 * Copyright (c) by Jaroslav Kysela <perex@suse.cz>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #include <sound/driver.h>
23 #include <linux/version.h>
24 #include <linux/init.h>
25 #include <linux/vmalloc.h>
26 #include <linux/time.h>
27 #include <linux/smp_lock.h>
28 #include <sound/core.h>
29 #include <sound/minors.h>
30 #include <sound/info.h>
31 #include <sound/version.h>
32 #include <linux/proc_fs.h>
33 #include <linux/devfs_fs_kernel.h>
40 int snd_info_check_reserved_words(const char *str)
42 static char *reserved[] =
57 char **xstr = reserved;
60 if (!strcmp(*xstr, str))
64 if (!strncmp(str, "card", 4))
71 static DECLARE_MUTEX(info_mutex);
73 typedef struct _snd_info_private_data {
74 snd_info_buffer_t *rbuffer;
75 snd_info_buffer_t *wbuffer;
76 snd_info_entry_t *entry;
77 void *file_private_data;
78 } snd_info_private_data_t;
80 static int snd_info_version_init(void);
81 static int snd_info_version_done(void);
85 * snd_iprintf - printf on the procfs buffer
86 * @buffer: the procfs buffer
87 * @fmt: the printf format
89 * Outputs the string on the procfs buffer just like printf().
91 * Returns the size of output string.
93 int snd_iprintf(snd_info_buffer_t * buffer, char *fmt,...)
99 if (buffer->stop || buffer->error)
102 res = vscnprintf(sbuffer, sizeof(sbuffer), fmt, args);
104 if (buffer->size + res >= buffer->len) {
108 strcpy(buffer->curr, sbuffer);
118 static struct proc_dir_entry *snd_proc_root = NULL;
119 snd_info_entry_t *snd_seq_root = NULL;
120 #ifdef CONFIG_SND_OSSEMUL
121 snd_info_entry_t *snd_oss_root = NULL;
124 static inline void snd_info_entry_prepare(struct proc_dir_entry *de)
126 de->owner = THIS_MODULE;
129 void snd_remove_proc_entry(struct proc_dir_entry *parent,
130 struct proc_dir_entry *de)
133 remove_proc_entry(de->name, parent);
136 static loff_t snd_info_entry_llseek(struct file *file, loff_t offset, int orig)
138 snd_info_private_data_t *data;
139 struct snd_info_entry *entry;
142 data = snd_magic_cast(snd_info_private_data_t, file->private_data, return -ENXIO);
145 switch (entry->content) {
146 case SNDRV_INFO_CONTENT_TEXT:
148 case 0: /* SEEK_SET */
149 file->f_pos = offset;
152 case 1: /* SEEK_CUR */
153 file->f_pos += offset;
156 case 2: /* SEEK_END */
162 case SNDRV_INFO_CONTENT_DATA:
163 if (entry->c.ops->llseek) {
164 ret = entry->c.ops->llseek(entry,
165 data->file_private_data,
177 static ssize_t snd_info_entry_read(struct file *file, char __user *buffer,
178 size_t count, loff_t * offset)
180 snd_info_private_data_t *data;
181 struct snd_info_entry *entry;
182 snd_info_buffer_t *buf;
186 data = snd_magic_cast(snd_info_private_data_t, file->private_data, return -ENXIO);
187 snd_assert(data != NULL, return -ENXIO);
189 if (pos < 0 || (long) pos != pos || (ssize_t) count < 0)
191 if ((unsigned long) pos + (unsigned long) count < (unsigned long) pos)
194 switch (entry->content) {
195 case SNDRV_INFO_CONTENT_TEXT:
199 if (pos >= buf->size)
201 size = buf->size - pos;
202 size = min(count, size);
203 if (copy_to_user(buffer, buf->buffer + pos, size))
206 case SNDRV_INFO_CONTENT_DATA:
207 if (entry->c.ops->read)
208 size = entry->c.ops->read(entry,
209 data->file_private_data,
210 file, buffer, count, pos);
213 if ((ssize_t) size > 0)
214 *offset = pos + size;
218 static ssize_t snd_info_entry_write(struct file *file, const char __user *buffer,
219 size_t count, loff_t * offset)
221 snd_info_private_data_t *data;
222 struct snd_info_entry *entry;
223 snd_info_buffer_t *buf;
227 data = snd_magic_cast(snd_info_private_data_t, file->private_data, return -ENXIO);
228 snd_assert(data != NULL, return -ENXIO);
231 if (pos < 0 || (long) pos != pos || (ssize_t) count < 0)
233 if ((unsigned long) pos + (unsigned long) count < (unsigned long) pos)
235 switch (entry->content) {
236 case SNDRV_INFO_CONTENT_TEXT:
242 size = buf->len - pos;
243 size = min(count, size);
244 if (copy_from_user(buf->buffer + pos, buffer, size))
246 if ((long)buf->size < pos + size)
247 buf->size = pos + size;
249 case SNDRV_INFO_CONTENT_DATA:
250 if (entry->c.ops->write)
251 size = entry->c.ops->write(entry,
252 data->file_private_data,
253 file, buffer, count, pos);
256 if ((ssize_t) size > 0)
257 *offset = pos + size;
261 static int snd_info_entry_open(struct inode *inode, struct file *file)
263 snd_info_entry_t *entry;
264 snd_info_private_data_t *data;
265 snd_info_buffer_t *buffer;
266 struct proc_dir_entry *p;
271 entry = p == NULL ? NULL : (snd_info_entry_t *)p->data;
272 if (entry == NULL || entry->disconnected) {
276 if (!try_module_get(entry->module)) {
280 mode = file->f_flags & O_ACCMODE;
281 if (mode == O_RDONLY || mode == O_RDWR) {
282 if ((entry->content == SNDRV_INFO_CONTENT_TEXT &&
283 !entry->c.text.read_size) ||
284 (entry->content == SNDRV_INFO_CONTENT_DATA &&
285 entry->c.ops->read == NULL)) {
290 if (mode == O_WRONLY || mode == O_RDWR) {
291 if ((entry->content == SNDRV_INFO_CONTENT_TEXT &&
292 !entry->c.text.write_size) ||
293 (entry->content == SNDRV_INFO_CONTENT_DATA &&
294 entry->c.ops->write == NULL)) {
299 data = snd_magic_kcalloc(snd_info_private_data_t, 0, GFP_KERNEL);
305 switch (entry->content) {
306 case SNDRV_INFO_CONTENT_TEXT:
307 if (mode == O_RDONLY || mode == O_RDWR) {
308 buffer = (snd_info_buffer_t *)
309 snd_kcalloc(sizeof(snd_info_buffer_t), GFP_KERNEL);
310 if (buffer == NULL) {
311 snd_magic_kfree(data);
315 buffer->len = (entry->c.text.read_size +
316 (PAGE_SIZE - 1)) & ~(PAGE_SIZE - 1);
317 buffer->buffer = vmalloc(buffer->len);
318 if (buffer->buffer == NULL) {
320 snd_magic_kfree(data);
324 buffer->curr = buffer->buffer;
325 data->rbuffer = buffer;
327 if (mode == O_WRONLY || mode == O_RDWR) {
328 buffer = (snd_info_buffer_t *)
329 snd_kcalloc(sizeof(snd_info_buffer_t), GFP_KERNEL);
330 if (buffer == NULL) {
331 if (mode == O_RDWR) {
332 vfree(data->rbuffer->buffer);
333 kfree(data->rbuffer);
335 snd_magic_kfree(data);
339 buffer->len = (entry->c.text.write_size +
340 (PAGE_SIZE - 1)) & ~(PAGE_SIZE - 1);
341 buffer->buffer = vmalloc(buffer->len);
342 if (buffer->buffer == NULL) {
343 if (mode == O_RDWR) {
344 vfree(data->rbuffer->buffer);
345 kfree(data->rbuffer);
348 snd_magic_kfree(data);
352 buffer->curr = buffer->buffer;
353 data->wbuffer = buffer;
356 case SNDRV_INFO_CONTENT_DATA: /* data */
357 if (entry->c.ops->open) {
358 if ((err = entry->c.ops->open(entry, mode,
359 &data->file_private_data)) < 0) {
360 snd_magic_kfree(data);
366 file->private_data = data;
368 if (entry->content == SNDRV_INFO_CONTENT_TEXT &&
369 (mode == O_RDONLY || mode == O_RDWR)) {
370 if (entry->c.text.read) {
371 down(&entry->access);
372 entry->c.text.read(entry, data->rbuffer);
379 module_put(entry->module);
385 static int snd_info_entry_release(struct inode *inode, struct file *file)
387 snd_info_entry_t *entry;
388 snd_info_private_data_t *data;
391 mode = file->f_flags & O_ACCMODE;
392 data = snd_magic_cast(snd_info_private_data_t, file->private_data, return -ENXIO);
394 switch (entry->content) {
395 case SNDRV_INFO_CONTENT_TEXT:
396 if (mode == O_RDONLY || mode == O_RDWR) {
397 vfree(data->rbuffer->buffer);
398 kfree(data->rbuffer);
400 if (mode == O_WRONLY || mode == O_RDWR) {
401 if (entry->c.text.write) {
402 entry->c.text.write(entry, data->wbuffer);
403 if (data->wbuffer->error) {
404 snd_printk(KERN_WARNING "data write error to %s (%i)\n",
406 data->wbuffer->error);
409 vfree(data->wbuffer->buffer);
410 kfree(data->wbuffer);
413 case SNDRV_INFO_CONTENT_DATA:
414 if (entry->c.ops->release)
415 entry->c.ops->release(entry, mode,
416 data->file_private_data);
419 module_put(entry->module);
420 snd_magic_kfree(data);
424 static unsigned int snd_info_entry_poll(struct file *file, poll_table * wait)
426 snd_info_private_data_t *data;
427 struct snd_info_entry *entry;
430 data = snd_magic_cast(snd_info_private_data_t, file->private_data, return -ENXIO);
435 switch (entry->content) {
436 case SNDRV_INFO_CONTENT_DATA:
437 if (entry->c.ops->poll)
438 return entry->c.ops->poll(entry,
439 data->file_private_data,
441 if (entry->c.ops->read)
442 mask |= POLLIN | POLLRDNORM;
443 if (entry->c.ops->write)
444 mask |= POLLOUT | POLLWRNORM;
450 static int snd_info_entry_ioctl(struct inode *inode, struct file *file,
451 unsigned int cmd, unsigned long arg)
453 snd_info_private_data_t *data;
454 struct snd_info_entry *entry;
456 data = snd_magic_cast(snd_info_private_data_t, file->private_data, return -ENXIO);
460 switch (entry->content) {
461 case SNDRV_INFO_CONTENT_DATA:
462 if (entry->c.ops->ioctl)
463 return entry->c.ops->ioctl(entry,
464 data->file_private_data,
471 static int snd_info_entry_mmap(struct file *file, struct vm_area_struct *vma)
473 struct inode *inode = file->f_dentry->d_inode;
474 snd_info_private_data_t *data;
475 struct snd_info_entry *entry;
477 data = snd_magic_cast(snd_info_private_data_t, file->private_data, return -ENXIO);
481 switch (entry->content) {
482 case SNDRV_INFO_CONTENT_DATA:
483 if (entry->c.ops->mmap)
484 return entry->c.ops->mmap(entry,
485 data->file_private_data,
492 static struct file_operations snd_info_entry_operations =
494 .owner = THIS_MODULE,
495 .llseek = snd_info_entry_llseek,
496 .read = snd_info_entry_read,
497 .write = snd_info_entry_write,
498 .poll = snd_info_entry_poll,
499 .ioctl = snd_info_entry_ioctl,
500 .mmap = snd_info_entry_mmap,
501 .open = snd_info_entry_open,
502 .release = snd_info_entry_release,
506 * snd_create_proc_entry - create a procfs entry
507 * @name: the name of the proc file
508 * @mode: the file permission bits, S_Ixxx
509 * @parent: the parent proc-directory entry
511 * Creates a new proc file entry with the given name and permission
512 * on the given directory.
514 * Returns the pointer of new instance or NULL on failure.
516 struct proc_dir_entry *snd_create_proc_entry(const char *name, mode_t mode,
517 struct proc_dir_entry *parent)
519 struct proc_dir_entry *p;
520 p = create_proc_entry(name, mode, parent);
522 snd_info_entry_prepare(p);
526 int __init snd_info_init(void)
528 struct proc_dir_entry *p;
530 p = snd_create_proc_entry("asound", S_IFDIR | S_IRUGO | S_IXUGO, &proc_root);
534 #ifdef CONFIG_SND_OSSEMUL
536 snd_info_entry_t *entry;
537 if ((entry = snd_info_create_module_entry(THIS_MODULE, "oss", NULL)) == NULL)
539 entry->mode = S_IFDIR | S_IRUGO | S_IXUGO;
540 if (snd_info_register(entry) < 0) {
541 snd_info_free_entry(entry);
544 snd_oss_root = entry;
547 #if defined(CONFIG_SND_SEQUENCER) || defined(CONFIG_SND_SEQUENCER_MODULE)
549 snd_info_entry_t *entry;
550 if ((entry = snd_info_create_module_entry(THIS_MODULE, "seq", NULL)) == NULL)
552 entry->mode = S_IFDIR | S_IRUGO | S_IXUGO;
553 if (snd_info_register(entry) < 0) {
554 snd_info_free_entry(entry);
557 snd_seq_root = entry;
560 snd_info_version_init();
561 snd_memory_info_init();
562 snd_minor_info_init();
563 snd_minor_info_oss_init();
564 snd_card_info_init();
568 int __exit snd_info_done(void)
570 snd_card_info_done();
571 snd_minor_info_oss_done();
572 snd_minor_info_done();
573 snd_memory_info_done();
574 snd_info_version_done();
576 #if defined(CONFIG_SND_SEQUENCER) || defined(CONFIG_SND_SEQUENCER_MODULE)
578 snd_info_unregister(snd_seq_root);
580 #ifdef CONFIG_SND_OSSEMUL
582 snd_info_unregister(snd_oss_root);
584 snd_remove_proc_entry(&proc_root, snd_proc_root);
595 * create a card proc file
598 int snd_info_card_create(snd_card_t * card)
601 snd_info_entry_t *entry;
603 snd_assert(card != NULL, return -ENXIO);
605 sprintf(str, "card%i", card->number);
606 if ((entry = snd_info_create_module_entry(card->module, str, NULL)) == NULL)
608 entry->mode = S_IFDIR | S_IRUGO | S_IXUGO;
609 if (snd_info_register(entry) < 0) {
610 snd_info_free_entry(entry);
613 card->proc_root = entry;
618 * register the card proc file
621 int snd_info_card_register(snd_card_t * card)
623 struct proc_dir_entry *p;
625 snd_assert(card != NULL, return -ENXIO);
627 if (!strcmp(card->id, card->proc_root->name))
630 p = proc_symlink(card->id, snd_proc_root, card->proc_root->name);
633 card->proc_root_link = p;
638 * de-register the card proc file
641 int snd_info_card_free(snd_card_t * card)
643 snd_assert(card != NULL, return -ENXIO);
644 if (card->proc_root_link) {
645 snd_remove_proc_entry(snd_proc_root, card->proc_root_link);
646 card->proc_root_link = NULL;
648 if (card->proc_root) {
649 snd_info_unregister(card->proc_root);
650 card->proc_root = NULL;
657 * snd_info_get_line - read one line from the procfs buffer
658 * @buffer: the procfs buffer
659 * @line: the buffer to store
660 * @len: the max. buffer size - 1
662 * Reads one line from the buffer and stores the string.
664 * Returns zero if successful, or 1 if error or EOF.
666 int snd_info_get_line(snd_info_buffer_t * buffer, char *line, int len)
670 if (len <= 0 || buffer->stop || buffer->error)
675 if ((buffer->curr - buffer->buffer) >= (long)buffer->size) {
681 if ((buffer->curr - buffer->buffer) >= (long)buffer->size) {
686 while (c != '\n' && !buffer->stop) {
688 if ((buffer->curr - buffer->buffer) >= (long)buffer->size) {
697 * snd_info_get_line - parse a string token
698 * @dest: the buffer to store the string token
699 * @src: the original string
700 * @len: the max. length of token - 1
702 * Parses the original string and copy a token to the given
705 * Returns the updated pointer of the original string so that
706 * it can be used for the next call.
708 char *snd_info_get_str(char *dest, char *src, int len)
712 while (*src == ' ' || *src == '\t')
714 if (*src == '"' || *src == '\'') {
716 while (--len > 0 && *src && *src != c) {
722 while (--len > 0 && *src && *src != ' ' && *src != '\t') {
727 while (*src == ' ' || *src == '\t')
733 * snd_info_create_entry - create an info entry
734 * @name: the proc file name
736 * Creates an info entry with the given file name and initializes as
739 * Usually called from other functions such as
740 * snd_info_create_card_entry().
742 * Returns the pointer of the new instance, or NULL on failure.
744 static snd_info_entry_t *snd_info_create_entry(const char *name)
746 snd_info_entry_t *entry;
747 entry = snd_magic_kcalloc(snd_info_entry_t, 0, GFP_KERNEL);
750 entry->name = snd_kmalloc_strdup(name, GFP_KERNEL);
751 if (entry->name == NULL) {
752 snd_magic_kfree(entry);
755 entry->mode = S_IFREG | S_IRUGO;
756 entry->content = SNDRV_INFO_CONTENT_TEXT;
757 init_MUTEX(&entry->access);
762 * snd_info_create_module_entry - create an info entry for the given module
763 * @module: the module pointer
764 * @name: the file name
765 * @parent: the parent directory
767 * Creates a new info entry and assigns it to the given module.
769 * Returns the pointer of the new instance, or NULL on failure.
771 snd_info_entry_t *snd_info_create_module_entry(struct module * module,
773 snd_info_entry_t *parent)
775 snd_info_entry_t *entry = snd_info_create_entry(name);
777 entry->module = module;
778 entry->parent = parent;
784 * snd_info_create_card_entry - create an info entry for the given card
785 * @card: the card instance
786 * @name: the file name
787 * @parent: the parent directory
789 * Creates a new info entry and assigns it to the given card.
791 * Returns the pointer of the new instance, or NULL on failure.
793 snd_info_entry_t *snd_info_create_card_entry(snd_card_t * card,
795 snd_info_entry_t * parent)
797 snd_info_entry_t *entry = snd_info_create_entry(name);
799 entry->module = card->module;
801 entry->parent = parent;
806 static int snd_info_dev_free_entry(snd_device_t *device)
808 snd_info_entry_t *entry = snd_magic_cast(snd_info_entry_t, device->device_data, return -ENXIO);
809 snd_info_free_entry(entry);
813 static int snd_info_dev_register_entry(snd_device_t *device)
815 snd_info_entry_t *entry = snd_magic_cast(snd_info_entry_t, device->device_data, return -ENXIO);
816 return snd_info_register(entry);
819 static int snd_info_dev_disconnect_entry(snd_device_t *device)
821 snd_info_entry_t *entry = snd_magic_cast(snd_info_entry_t, device->device_data, return -ENXIO);
822 entry->disconnected = 1;
826 static int snd_info_dev_unregister_entry(snd_device_t *device)
828 snd_info_entry_t *entry = snd_magic_cast(snd_info_entry_t, device->device_data, return -ENXIO);
829 return snd_info_unregister(entry);
833 * snd_card_proc_new - create an info entry for the given card
834 * @card: the card instance
835 * @name: the file name
836 * @entryp: the pointer to store the new info entry
838 * Creates a new info entry and assigns it to the given card.
839 * Unlike snd_info_create_card_entry(), this function registers the
840 * info entry as an ALSA device component, so that it can be
841 * unregistered/released without explicit call.
842 * Also, you don't have to register this entry via snd_info_register(),
843 * since this will be registered by snd_card_register() automatically.
845 * The parent is assumed as card->proc_root.
847 * For releasing this entry, use snd_device_free() instead of
848 * snd_info_free_entry().
850 * Returns zero if successful, or a negative error code on failure.
852 int snd_card_proc_new(snd_card_t *card, const char *name,
853 snd_info_entry_t **entryp)
855 static snd_device_ops_t ops = {
856 .dev_free = snd_info_dev_free_entry,
857 .dev_register = snd_info_dev_register_entry,
858 .dev_disconnect = snd_info_dev_disconnect_entry,
859 .dev_unregister = snd_info_dev_unregister_entry
861 snd_info_entry_t *entry;
864 entry = snd_info_create_card_entry(card, name, card->proc_root);
867 if ((err = snd_device_new(card, SNDRV_DEV_INFO, entry, &ops)) < 0) {
868 snd_info_free_entry(entry);
877 * snd_info_free_entry - release the info entry
878 * @entry: the info entry
880 * Releases the info entry. Don't call this after registered.
882 void snd_info_free_entry(snd_info_entry_t * entry)
887 kfree((char *)entry->name);
888 if (entry->private_free)
889 entry->private_free(entry);
890 snd_magic_kfree(entry);
894 * snd_info_register - register the info entry
895 * @entry: the info entry
897 * Registers the proc info entry.
899 * Returns zero if successful, or a negative error code on failure.
901 int snd_info_register(snd_info_entry_t * entry)
903 struct proc_dir_entry *root, *p = NULL;
905 snd_assert(entry != NULL, return -ENXIO);
906 root = entry->parent == NULL ? snd_proc_root : entry->parent->p;
908 p = snd_create_proc_entry(entry->name, entry->mode, root);
913 p->owner = entry->module;
914 if (!S_ISDIR(entry->mode))
915 p->proc_fops = &snd_info_entry_operations;
916 p->size = entry->size;
924 * snd_info_unregister - de-register the info entry
925 * @entry: the info entry
927 * De-registers the info entry and releases the instance.
929 * Returns zero if successful, or a negative error code on failure.
931 int snd_info_unregister(snd_info_entry_t * entry)
933 struct proc_dir_entry *root;
935 snd_assert(entry != NULL && entry->p != NULL, return -ENXIO);
936 root = entry->parent == NULL ? snd_proc_root : entry->parent->p;
937 snd_assert(root, return -ENXIO);
939 snd_remove_proc_entry(root, entry->p);
941 snd_info_free_entry(entry);
949 static snd_info_entry_t *snd_info_version_entry = NULL;
951 static void snd_info_version_read(snd_info_entry_t *entry, snd_info_buffer_t * buffer)
953 static char *kernel_version = UTS_RELEASE;
956 "Advanced Linux Sound Architecture Driver Version " CONFIG_SND_VERSION CONFIG_SND_DATE ".\n"
957 "Compiled on " __DATE__ " for kernel %s"
962 " with versioned symbols"
964 ".\n", kernel_version);
967 static int __init snd_info_version_init(void)
969 snd_info_entry_t *entry;
971 entry = snd_info_create_module_entry(THIS_MODULE, "version", NULL);
974 entry->c.text.read_size = 256;
975 entry->c.text.read = snd_info_version_read;
976 if (snd_info_register(entry) < 0) {
977 snd_info_free_entry(entry);
980 snd_info_version_entry = entry;
984 static int __exit snd_info_version_done(void)
986 if (snd_info_version_entry)
987 snd_info_unregister(snd_info_version_entry);
991 #endif /* CONFIG_PROC_FS */