static int snd_compress_proc_init(struct snd_compr *compr) { struct snd_info_entry *entry; char name[16]; sprintf(name, "compr%i", compr->device); entry = snd_info_create_card_entry(compr->card, name, compr->card->proc_root); if (!entry) return -ENOMEM; entry->mode = S_IFDIR | S_IRUGO | S_IXUGO; if (snd_info_register(entry) < 0) { snd_info_free_entry(entry); return -ENOMEM; } compr->proc_root = entry; entry = snd_info_create_card_entry(compr->card, "info", compr->proc_root); if (entry) { snd_info_set_text_ops(entry, compr, snd_compress_proc_info_read); if (snd_info_register(entry) < 0) { snd_info_free_entry(entry); entry = NULL; } } compr->proc_info_entry = entry; return 0; }
static void snd_compress_proc_done(struct snd_compr *compr) { snd_info_free_entry(compr->proc_info_entry); compr->proc_info_entry = NULL; snd_info_free_entry(compr->proc_root); compr->proc_root = NULL; }
static inline void preallocate_info_init(struct snd_pcm_substream *substream) { struct snd_info_entry *entry; if ((entry = snd_info_create_card_entry(substream->pcm->card, "prealloc", substream->proc_root)) != NULL) { entry->c.text.read = snd_pcm_lib_preallocate_proc_read; entry->c.text.write = snd_pcm_lib_preallocate_proc_write; entry->mode |= 0200; entry->private_data = substream; if (snd_info_register(entry) < 0) { snd_info_free_entry(entry); entry = NULL; } } substream->proc_prealloc_entry = entry; if ((entry = snd_info_create_card_entry(substream->pcm->card, "prealloc_max", substream->proc_root)) != NULL) { entry->c.text.read = snd_pcm_lib_preallocate_max_proc_read; entry->private_data = substream; if (snd_info_register(entry) < 0) { snd_info_free_entry(entry); entry = NULL; } } substream->proc_prealloc_max_entry = entry; }
int __exit snd_seq_info_done(void) { snd_info_free_entry(queues_entry); snd_info_free_entry(clients_entry); snd_info_free_entry(timer_entry); return 0; }
void snd_dg00x_proc_init(struct snd_dg00x *dg00x) { struct snd_info_entry *root, *entry; /* * All nodes are automatically removed at snd_card_disconnect(), * by following to link list. */ root = snd_info_create_card_entry(dg00x->card, "firewire", dg00x->card->proc_root); if (root == NULL) return; root->mode = S_IFDIR | S_IRUGO | S_IXUGO; if (snd_info_register(root) < 0) { snd_info_free_entry(root); return; } entry = snd_info_create_card_entry(dg00x->card, "clock", root); if (entry == NULL) { snd_info_free_entry(root); return; } snd_info_set_text_ops(entry, dg00x, proc_read_clock); if (snd_info_register(entry) < 0) { snd_info_free_entry(entry); snd_info_free_entry(root); } }
/** * snd_pcm_lib_preallocate_free - release the preallocated buffer of the specified substream. * @substream: the pcm substream instance * * Releases the pre-allocated buffer of the given substream. * * Return: Zero if successful, or a negative error code on failure. */ int snd_pcm_lib_preallocate_free(struct snd_pcm_substream *substream) { snd_pcm_lib_preallocate_dma_free(substream); #ifdef CONFIG_SND_VERBOSE_PROCFS snd_info_free_entry(substream->proc_prealloc_max_entry); substream->proc_prealloc_max_entry = NULL; snd_info_free_entry(substream->proc_prealloc_entry); substream->proc_prealloc_entry = NULL; #endif return 0; }
void snd_bebob_proc_init(struct snd_bebob *bebob) { struct snd_info_entry *root; /* * All nodes are automatically removed at snd_card_disconnect(), * by following to link list. */ root = snd_info_create_card_entry(bebob->card, "firewire", bebob->card->proc_root); if (root == NULL) return; root->mode = S_IFDIR | S_IRUGO | S_IXUGO; if (snd_info_register(root) < 0) { snd_info_free_entry(root); return; } add_node(bebob, root, "clock", proc_read_clock); add_node(bebob, root, "firmware", proc_read_hw_info); add_node(bebob, root, "formation", proc_read_formation); if (bebob->spec->meter != NULL) add_node(bebob, root, "meter", proc_read_meters); }
int snd_opl4_create_proc(struct snd_opl4 *opl4) { struct snd_info_entry *entry; entry = snd_info_create_card_entry(opl4->card, "opl4-mem", opl4->card->proc_root); if (entry) { if (opl4->hardware < OPL3_HW_OPL4_ML) { /* OPL4 can access 4 MB external ROM/SRAM */ entry->mode |= S_IWUSR; entry->size = 4 * 1024 * 1024; } else { /* OPL4-ML has 1 MB internal ROM */ entry->size = 1 * 1024 * 1024; } entry->content = SNDRV_INFO_CONTENT_DATA; entry->c.ops = &snd_opl4_mem_proc_ops; entry->module = THIS_MODULE; entry->private_data = opl4; if (snd_info_register(entry) < 0) { snd_info_free_entry(entry); entry = NULL; } } opl4->proc_entry = entry; return 0; }
/* * 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) { snd_info_entry_t *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; entry->c.text.write_size = 64; entry->c.text.write = snd_pcm_lib_preallocate_proc_write; entry->private_data = substream; if (snd_info_register(entry) < 0) { snd_info_free_entry(entry); entry = NULL; } } substream->proc_prealloc_entry = entry; return 0; }
int __exit snd_info_done(void) { snd_card_info_done(); snd_minor_info_oss_done(); snd_minor_info_done(); snd_info_version_done(); if (snd_proc_root) { #if defined(CONFIG_SND_SEQUENCER) || defined(CONFIG_SND_SEQUENCER_MODULE) snd_info_free_entry(snd_seq_root); #endif #ifdef CONFIG_SND_OSSEMUL snd_info_free_entry(snd_oss_root); #endif snd_remove_proc_entry(&proc_root, snd_proc_root); } return 0; }
snd_info_entry_t *snd_info_create_device(const char *name, unsigned int number, unsigned int mode) { #ifdef CONFIG_DEVFS_FS char dname[32]; #endif unsigned short major = number >> 16; unsigned short minor = (unsigned short) number; snd_info_entry_t *entry; struct proc_dir_entry *p = NULL; if (!major) major = snd_major; if (!mode) mode = S_IFCHR | S_IRUGO | S_IWUGO; mode &= (snd_device_mode & (S_IRUGO | S_IWUGO)) | S_IFCHR | S_IFBLK; entry = snd_info_create_module_entry(THIS_MODULE, name, NULL); if (entry == NULL) return NULL; entry->content = SNDRV_INFO_CONTENT_DEVICE; entry->mode = mode; entry->c.device.major = major; entry->c.device.minor = minor; down(&info_mutex); p = create_proc_entry(entry->name, entry->mode, snd_proc_dev); if (p) { #ifndef TARGET_OS2 snd_info_device_entry_prepare(p, entry); #ifdef LINUX_2_3 p->proc_fops = &snd_fops; #else p->ops = &snd_info_device_inode_operations; #endif #endif } else { up(&info_mutex); snd_info_free_entry(entry); return NULL; } p->gid = snd_device_gid; p->uid = snd_device_uid; p->data = (void *) entry; entry->p = p; up(&info_mutex); #ifdef CONFIG_DEVFS_FS if (strncmp(name, "controlC", 8)) { /* created in sound.c */ sprintf(dname, "snd/%s", name); devfs_register(NULL, dname, DEVFS_FL_DEFAULT, major, minor, mode, &snd_fops, NULL); } #endif return entry; }
int __init snd_info_init(void) { struct proc_dir_entry *p; p = snd_create_proc_entry("asound", S_IFDIR | S_IRUGO | S_IXUGO, &proc_root); if (p == NULL) return -ENOMEM; snd_proc_root = p; #ifdef CONFIG_SND_OSSEMUL { 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; if (snd_info_register(entry) < 0) { snd_info_free_entry(entry); return -ENOMEM; } snd_oss_root = entry; } #endif #if defined(CONFIG_SND_SEQUENCER) || defined(CONFIG_SND_SEQUENCER_MODULE) { 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; if (snd_info_register(entry) < 0) { snd_info_free_entry(entry); return -ENOMEM; } snd_seq_root = entry; } #endif snd_info_version_init(); snd_minor_info_init(); snd_minor_info_oss_init(); snd_card_info_init(); return 0; }
int snd_info_unregister(snd_info_entry_t * entry) { struct proc_dir_entry *root; snd_assert(entry != NULL && entry->p != NULL, return -ENXIO); root = entry->parent == NULL ? snd_proc_root : entry->parent->p; snd_assert(root, return -ENXIO); down(&info_mutex); snd_remove_proc_entry(root, entry->p); up(&info_mutex); snd_info_free_entry(entry); return 0; }
static void __init snd_hwdep_proc_init(void) { struct snd_info_entry *entry; if ((entry = snd_info_create_module_entry(THIS_MODULE, "hwdep", NULL)) != NULL) { entry->c.text.read = snd_hwdep_proc_read; if (snd_info_register(entry) < 0) { snd_info_free_entry(entry); entry = NULL; } } snd_hwdep_proc_entry = entry; }
static void add_node(struct snd_efw *efw, struct snd_info_entry *root, const char *name, void (*op)(struct snd_info_entry *e, struct snd_info_buffer *b)) { struct snd_info_entry *entry; entry = snd_info_create_card_entry(efw->card, name, root); if (entry == NULL) return; snd_info_set_text_ops(entry, efw, op); if (snd_info_register(entry) < 0) snd_info_free_entry(entry); }
static int i2s_debug_init(struct snd_soc_card *card) { struct snd_info_entry *entry; if ((entry = snd_info_create_card_entry(card->snd_card, "i2s-debug", card->snd_card->proc_root)) != NULL) { entry->c.text.read = i2s_debug_read; entry->c.text.write = i2s_debug_write; entry->mode |= S_IWUSR; if (snd_info_register(entry) < 0) { snd_info_free_entry(entry); entry = NULL; } } return 0; }
int snd_info_minor_register(void) { 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) { entry->c.text.read = snd_sndstat_proc_read; if (snd_info_register(entry) < 0) { snd_info_free_entry(entry); entry = NULL; } } snd_sndstat_proc_entry = entry; return 0; }
int __init snd_minor_info_init(void) { struct snd_info_entry *entry; entry = snd_info_create_module_entry(THIS_MODULE, "devices", NULL); if (entry) { entry->c.text.read = snd_minor_info_read; if (snd_info_register(entry) < 0) { snd_info_free_entry(entry); entry = NULL; } } snd_minor_info_entry = entry; return 0; }
static int __init snd_info_version_init(void) { snd_info_entry_t *entry; entry = snd_info_create_module_entry(THIS_MODULE, "version", NULL); if (entry == NULL) return -ENOMEM; entry->c.text.read_size = 256; entry->c.text.read = snd_info_version_read; if (snd_info_register(entry) < 0) { snd_info_free_entry(entry); return -ENOMEM; } snd_info_version_entry = entry; return 0; }
int snd_info_minor_register(void) { snd_info_entry_t *entry; memset(snd_sndstat_strings, 0, sizeof(snd_sndstat_strings)); if ((entry = snd_info_create_module_entry(THIS_MODULE, "sndstat", snd_oss_root)) != NULL) { entry->content = SNDRV_INFO_CONTENT_TEXT; entry->c.text.read_size = 2048; entry->c.text.read = snd_sndstat_proc_read; if (snd_info_register(entry) < 0) { snd_info_free_entry(entry); entry = NULL; } } snd_sndstat_proc_entry = entry; return 0; }
static struct snd_info_entry * __init create_info_entry(char *name, void (*read)(struct snd_info_entry *, struct snd_info_buffer *)) { struct snd_info_entry *entry; entry = snd_info_create_module_entry(THIS_MODULE, name, snd_seq_root); if (entry == NULL) return NULL; entry->content = SNDRV_INFO_CONTENT_TEXT; entry->c.text.read = read; if (snd_info_register(entry) < 0) { snd_info_free_entry(entry); return NULL; } return entry; }
int __init snd_memory_info_init(void) { snd_info_entry_t *entry; entry = snd_info_create_module_entry(THIS_MODULE, "meminfo", NULL); if (entry) { entry->content = SNDRV_INFO_CONTENT_TEXT; entry->c.text.read_size = 256; entry->c.text.read = snd_memory_info_read; if (snd_info_register(entry) < 0) { snd_info_free_entry(entry); entry = NULL; } } snd_memory_info_entry = entry; return 0; }
void snd_gus_irq_profile_init(snd_gus_card_t *gus) { snd_info_entry_t *entry; gus->irq_entry = NULL; entry = snd_info_create_card_entry(gus->card, "gusirq", gus->card->proc_root); if (entry) { entry->content = SNDRV_INFO_CONTENT_TEXT; entry->c.text.read_size = 512; entry->c.text.read = snd_gus_irq_info_read; entry->private_data = gus; if (snd_info_register(entry) < 0) { snd_info_free_entry(entry); entry = NULL; } } gus->irq_entry = entry; }
/* * create a card proc file * called from init.c */ int snd_info_card_create(struct snd_card *card) { char str[8]; struct snd_info_entry *entry; snd_assert(card != NULL, return -ENXIO); sprintf(str, "card%i", card->number); if ((entry = snd_info_create_module_entry(card->module, str, NULL)) == NULL) return -ENOMEM; entry->mode = S_IFDIR | S_IRUGO | S_IXUGO; if (snd_info_register(entry) < 0) { snd_info_free_entry(entry); return -ENOMEM; } card->proc_root = entry; return 0; }
void snd_emux_proc_init(struct snd_emux *emu, struct snd_card *card, int device) { struct snd_info_entry *entry; char name[64]; sprintf(name, "wavetableD%d", device); entry = snd_info_create_card_entry(card, name, card->proc_root); if (entry == NULL) return; entry->content = SNDRV_INFO_CONTENT_TEXT; entry->private_data = emu; entry->c.text.read = snd_emux_proc_info_read; if (snd_info_register(entry) < 0) snd_info_free_entry(entry); else emu->proc = entry; }
static int __init register_proc(void) { struct snd_info_entry *entry; entry = snd_info_create_module_entry(THIS_MODULE, SNDRV_SEQ_OSS_PROCNAME, snd_seq_root); if (entry == NULL) return -ENOMEM; entry->content = SNDRV_INFO_CONTENT_TEXT; entry->private_data = NULL; entry->c.text.read = info_read; if (snd_info_register(entry) < 0) { snd_info_free_entry(entry); return -ENOMEM; } info_entry = entry; return 0; }
void snd_info_free_device(snd_info_entry_t * entry) { #ifdef CONFIG_DEVFS_FS char dname[32]; devfs_handle_t master; #endif snd_runtime_check(entry, return); down(&info_mutex); snd_remove_proc_entry(snd_proc_dev, entry->p); up(&info_mutex); #ifdef CONFIG_DEVFS_FS if (entry->p && strncmp(entry->name, "controlC", 8)) { sprintf(dname, "snd/%s", entry->name); master = devfs_find_handle(NULL, dname, 0, 0, DEVFS_SPECIAL_CHR, 0); devfs_unregister(master); } #endif snd_info_free_entry(entry); }
void snd_motu_proc_init(struct snd_motu *motu) { struct snd_info_entry *root; /* * All nodes are automatically removed at snd_card_disconnect(), * by following to link list. */ root = snd_info_create_card_entry(motu->card, "firewire", motu->card->proc_root); if (root == NULL) return; root->mode = S_IFDIR | S_IRUGO | S_IXUGO; if (snd_info_register(root) < 0) { snd_info_free_entry(root); return; } add_node(motu, root, "clock", proc_read_clock); add_node(motu, root, "format", proc_read_format); }
int snd_info_card_register(snd_card_t * card) { char str[8]; char *s; snd_info_entry_t *entry; struct proc_dir_entry *p; snd_assert(card != NULL, return -ENXIO); sprintf(str, "card%i", card->number); if ((entry = snd_info_create_module_entry(card->module, str, NULL)) == NULL) return -ENOMEM; entry->mode = S_IFDIR | S_IRUGO | S_IXUGO; if (snd_info_register(entry) < 0) { snd_info_free_entry(entry); return -ENOMEM; } card->proc_root = entry; if (!strcmp(card->id, str)) return 0; s = snd_kmalloc_strdup(str, GFP_KERNEL); if (s == NULL) return -ENOMEM; p = snd_create_proc_entry(card->id, S_IFLNK | S_IRUGO | S_IWUGO | S_IXUGO, snd_proc_root); if (p == NULL) return -ENOMEM; p->data = s; #ifndef TARGET_OS2 #ifdef LINUX_2_3 p->owner = card->module; p->proc_iops = &snd_info_card_link_inode_operations; #else p->ops = &snd_info_card_link_inode_operations; #endif #endif card->proc_root_link = p; return 0; }
void snd_efw_proc_init(struct snd_efw *efw) { struct snd_info_entry *root; /* * All nodes are automatically removed at snd_card_disconnect(), * by following to link list. */ root = snd_info_create_card_entry(efw->card, "firewire", efw->card->proc_root); if (root == NULL) return; root->mode = S_IFDIR | S_IRUGO | S_IXUGO; if (snd_info_register(root) < 0) { snd_info_free_entry(root); return; } add_node(efw, root, "clock", proc_read_clock); add_node(efw, root, "firmware", proc_read_hwinfo); add_node(efw, root, "meters", proc_read_phys_meters); add_node(efw, root, "queues", proc_read_queues_state); }