blob: 051d55b05521216d31a1d011d58560744e930672 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Information interface for ALSA driver
Jaroslav Kyselac1017a42007-10-15 09:50:19 +02003 * Copyright (c) by Jaroslav Kysela <perex@perex.cz>
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 *
5 *
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.
10 *
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.
15 *
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
19 *
20 */
21
Linus Torvalds1da177e2005-04-16 15:20:36 -070022#include <linux/init.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070023#include <linux/time.h>
Andrea Righi27ac7922008-07-23 21:28:13 -070024#include <linux/mm.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090025#include <linux/slab.h>
Paulo Marques543537b2005-06-23 00:09:02 -070026#include <linux/string.h>
Paul Gortmakerda155d52011-07-15 12:38:28 -040027#include <linux/module.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070028#include <sound/core.h>
29#include <sound/minors.h>
30#include <sound/info.h>
Jaroslav Kysela42662742012-09-04 11:21:45 +020031#include <linux/utsname.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070032#include <linux/proc_fs.h>
Ingo Molnar1a60d4c2006-01-16 16:29:08 +010033#include <linux/mutex.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070034#include <stdarg.h>
35
36/*
37 *
38 */
39
Takashi Iwaie28563c2005-12-01 10:42:42 +010040#ifdef CONFIG_PROC_FS
41
Linus Torvalds1da177e2005-04-16 15:20:36 -070042int snd_info_check_reserved_words(const char *str)
43{
44 static char *reserved[] =
45 {
46 "version",
47 "meminfo",
48 "memdebug",
49 "detect",
50 "devices",
51 "oss",
52 "cards",
53 "timers",
54 "synth",
55 "pcm",
56 "seq",
57 NULL
58 };
59 char **xstr = reserved;
60
61 while (*xstr) {
62 if (!strcmp(*xstr, str))
63 return 0;
64 xstr++;
65 }
66 if (!strncmp(str, "card", 4))
67 return 0;
68 return 1;
69}
70
Ingo Molnar1a60d4c2006-01-16 16:29:08 +010071static DEFINE_MUTEX(info_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070072
Takashi Iwai24c1f932005-11-17 13:58:48 +010073struct snd_info_private_data {
74 struct snd_info_buffer *rbuffer;
75 struct snd_info_buffer *wbuffer;
76 struct snd_info_entry *entry;
Linus Torvalds1da177e2005-04-16 15:20:36 -070077 void *file_private_data;
Takashi Iwai24c1f932005-11-17 13:58:48 +010078};
Linus Torvalds1da177e2005-04-16 15:20:36 -070079
80static int snd_info_version_init(void);
81static int snd_info_version_done(void);
Takashi Iwai746d4a02006-06-23 14:37:59 +020082static void snd_info_disconnect(struct snd_info_entry *entry);
Linus Torvalds1da177e2005-04-16 15:20:36 -070083
84
Takashi Iwai7e4eeec2006-04-28 15:13:40 +020085/* resize the proc r/w buffer */
86static int resize_info_buffer(struct snd_info_buffer *buffer,
87 unsigned int nsize)
88{
89 char *nbuf;
90
91 nsize = PAGE_ALIGN(nsize);
Takashi Iwai0d861ac2013-03-13 12:01:13 +010092 nbuf = krealloc(buffer->buffer, nsize, GFP_KERNEL | __GFP_ZERO);
Takashi Iwai7e4eeec2006-04-28 15:13:40 +020093 if (! nbuf)
94 return -ENOMEM;
95
Takashi Iwai7e4eeec2006-04-28 15:13:40 +020096 buffer->buffer = nbuf;
97 buffer->len = nsize;
98 return 0;
99}
100
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101/**
102 * snd_iprintf - printf on the procfs buffer
103 * @buffer: the procfs buffer
104 * @fmt: the printf format
105 *
106 * Outputs the string on the procfs buffer just like printf().
107 *
Yacine Belkadieb7c06e2013-03-11 22:05:14 +0100108 * Return: The size of output string, or a negative error code.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109 */
Takashi Iwai4f7454a2009-09-08 14:29:58 +0200110int snd_iprintf(struct snd_info_buffer *buffer, const char *fmt, ...)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111{
112 va_list args;
113 int len, res;
Takashi Iwai7e4eeec2006-04-28 15:13:40 +0200114 int err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115
Takashi Iwaif001c3a2006-04-28 15:13:41 +0200116 might_sleep();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117 if (buffer->stop || buffer->error)
118 return 0;
119 len = buffer->len - buffer->size;
120 va_start(args, fmt);
Takashi Iwai7e4eeec2006-04-28 15:13:40 +0200121 for (;;) {
Takashi Iwaidbedca32006-10-18 19:09:46 +0200122 va_list ap;
123 va_copy(ap, args);
124 res = vsnprintf(buffer->buffer + buffer->curr, len, fmt, ap);
125 va_end(ap);
Takashi Iwai7e4eeec2006-04-28 15:13:40 +0200126 if (res < len)
127 break;
128 err = resize_info_buffer(buffer, buffer->len + PAGE_SIZE);
129 if (err < 0)
130 break;
131 len = buffer->len - buffer->size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132 }
Takashi Iwai7e4eeec2006-04-28 15:13:40 +0200133 va_end(args);
134
135 if (err < 0)
136 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137 buffer->curr += res;
138 buffer->size += res;
139 return res;
140}
141
Takashi Iwaic0d3fb32006-04-28 15:13:39 +0200142EXPORT_SYMBOL(snd_iprintf);
143
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144/*
145
146 */
147
Takashi Iwai6581f4e2006-05-17 17:14:51 +0200148static struct proc_dir_entry *snd_proc_root;
149struct snd_info_entry *snd_seq_root;
Takashi Iwaic0d3fb32006-04-28 15:13:39 +0200150EXPORT_SYMBOL(snd_seq_root);
151
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152#ifdef CONFIG_SND_OSSEMUL
Takashi Iwai6581f4e2006-05-17 17:14:51 +0200153struct snd_info_entry *snd_oss_root;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154#endif
155
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156static loff_t snd_info_entry_llseek(struct file *file, loff_t offset, int orig)
157{
Takashi Iwai24c1f932005-11-17 13:58:48 +0100158 struct snd_info_private_data *data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159 struct snd_info_entry *entry;
Takashi Iwai73029e02010-04-13 11:39:47 +0200160 loff_t ret = -EINVAL, size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161
162 data = file->private_data;
163 entry = data->entry;
Takashi Iwai5b5cd552010-04-07 18:33:57 +0200164 mutex_lock(&entry->access);
Takashi Iwai73029e02010-04-13 11:39:47 +0200165 if (entry->content == SNDRV_INFO_CONTENT_DATA &&
166 entry->c.ops->llseek) {
167 offset = entry->c.ops->llseek(entry,
168 data->file_private_data,
169 file, offset, orig);
170 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171 }
Takashi Iwai73029e02010-04-13 11:39:47 +0200172 if (entry->content == SNDRV_INFO_CONTENT_DATA)
173 size = entry->size;
174 else
175 size = 0;
176 switch (orig) {
177 case SEEK_SET:
178 break;
179 case SEEK_CUR:
180 offset += file->f_pos;
181 break;
182 case SEEK_END:
183 if (!size)
184 goto out;
185 offset += size;
186 break;
187 default:
188 goto out;
189 }
190 if (offset < 0)
191 goto out;
192 if (size && offset > size)
193 offset = size;
194 file->f_pos = offset;
195 ret = offset;
196 out:
Takashi Iwai5b5cd552010-04-07 18:33:57 +0200197 mutex_unlock(&entry->access);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198 return ret;
199}
200
201static ssize_t snd_info_entry_read(struct file *file, char __user *buffer,
202 size_t count, loff_t * offset)
203{
Takashi Iwai24c1f932005-11-17 13:58:48 +0100204 struct snd_info_private_data *data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205 struct snd_info_entry *entry;
Takashi Iwai24c1f932005-11-17 13:58:48 +0100206 struct snd_info_buffer *buf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207 size_t size = 0;
208 loff_t pos;
209
210 data = file->private_data;
Takashi Iwai7eaa9432008-08-08 17:09:09 +0200211 if (snd_BUG_ON(!data))
212 return -ENXIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 pos = *offset;
214 if (pos < 0 || (long) pos != pos || (ssize_t) count < 0)
215 return -EIO;
216 if ((unsigned long) pos + (unsigned long) count < (unsigned long) pos)
217 return -EIO;
218 entry = data->entry;
219 switch (entry->content) {
220 case SNDRV_INFO_CONTENT_TEXT:
221 buf = data->rbuffer;
222 if (buf == NULL)
223 return -EIO;
224 if (pos >= buf->size)
225 return 0;
226 size = buf->size - pos;
227 size = min(count, size);
228 if (copy_to_user(buffer, buf->buffer + pos, size))
229 return -EFAULT;
230 break;
231 case SNDRV_INFO_CONTENT_DATA:
Takashi Iwaid97e1b72010-04-13 11:33:54 +0200232 if (pos >= entry->size)
233 return 0;
234 if (entry->c.ops->read) {
235 size = entry->size - pos;
236 size = min(count, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237 size = entry->c.ops->read(entry,
238 data->file_private_data,
Takashi Iwaid97e1b72010-04-13 11:33:54 +0200239 file, buffer, size, pos);
240 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241 break;
242 }
243 if ((ssize_t) size > 0)
244 *offset = pos + size;
245 return size;
246}
247
248static ssize_t snd_info_entry_write(struct file *file, const char __user *buffer,
249 size_t count, loff_t * offset)
250{
Takashi Iwai24c1f932005-11-17 13:58:48 +0100251 struct snd_info_private_data *data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252 struct snd_info_entry *entry;
Takashi Iwai24c1f932005-11-17 13:58:48 +0100253 struct snd_info_buffer *buf;
Takashi Iwai7e4eeec2006-04-28 15:13:40 +0200254 ssize_t size = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255 loff_t pos;
256
257 data = file->private_data;
Takashi Iwai7eaa9432008-08-08 17:09:09 +0200258 if (snd_BUG_ON(!data))
259 return -ENXIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260 entry = data->entry;
261 pos = *offset;
262 if (pos < 0 || (long) pos != pos || (ssize_t) count < 0)
263 return -EIO;
264 if ((unsigned long) pos + (unsigned long) count < (unsigned long) pos)
265 return -EIO;
266 switch (entry->content) {
267 case SNDRV_INFO_CONTENT_TEXT:
268 buf = data->wbuffer;
269 if (buf == NULL)
270 return -EIO;
Clemens Ladischf4a747f2006-05-02 15:33:25 +0200271 mutex_lock(&entry->access);
Takashi Iwai7e4eeec2006-04-28 15:13:40 +0200272 if (pos + count >= buf->len) {
273 if (resize_info_buffer(buf, pos + count)) {
274 mutex_unlock(&entry->access);
275 return -ENOMEM;
276 }
277 }
278 if (copy_from_user(buf->buffer + pos, buffer, count)) {
279 mutex_unlock(&entry->access);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280 return -EFAULT;
Takashi Iwai7e4eeec2006-04-28 15:13:40 +0200281 }
282 buf->size = pos + count;
283 mutex_unlock(&entry->access);
284 size = count;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285 break;
286 case SNDRV_INFO_CONTENT_DATA:
Takashi Iwaid97e1b72010-04-13 11:33:54 +0200287 if (entry->c.ops->write && count > 0) {
288 size_t maxsize = entry->size - pos;
289 count = min(count, maxsize);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290 size = entry->c.ops->write(entry,
291 data->file_private_data,
292 file, buffer, count, pos);
Takashi Iwaid97e1b72010-04-13 11:33:54 +0200293 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294 break;
295 }
296 if ((ssize_t) size > 0)
297 *offset = pos + size;
298 return size;
299}
300
301static int snd_info_entry_open(struct inode *inode, struct file *file)
302{
Takashi Iwai24c1f932005-11-17 13:58:48 +0100303 struct snd_info_entry *entry;
304 struct snd_info_private_data *data;
305 struct snd_info_buffer *buffer;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306 int mode, err;
307
Ingo Molnar1a60d4c2006-01-16 16:29:08 +0100308 mutex_lock(&info_mutex);
Al Virod9dda782013-03-31 18:16:14 -0400309 entry = PDE_DATA(inode);
Takashi Iwai746d4a02006-06-23 14:37:59 +0200310 if (entry == NULL || ! entry->p) {
Ingo Molnar1a60d4c2006-01-16 16:29:08 +0100311 mutex_unlock(&info_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312 return -ENODEV;
313 }
314 if (!try_module_get(entry->module)) {
315 err = -EFAULT;
316 goto __error1;
317 }
318 mode = file->f_flags & O_ACCMODE;
319 if (mode == O_RDONLY || mode == O_RDWR) {
Takashi Iwai7e4eeec2006-04-28 15:13:40 +0200320 if ((entry->content == SNDRV_INFO_CONTENT_DATA &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321 entry->c.ops->read == NULL)) {
322 err = -ENODEV;
323 goto __error;
324 }
325 }
326 if (mode == O_WRONLY || mode == O_RDWR) {
Takashi Iwai7e4eeec2006-04-28 15:13:40 +0200327 if ((entry->content == SNDRV_INFO_CONTENT_DATA &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328 entry->c.ops->write == NULL)) {
329 err = -ENODEV;
330 goto __error;
331 }
332 }
Takashi Iwaica2c0962005-09-09 14:20:23 +0200333 data = kzalloc(sizeof(*data), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334 if (data == NULL) {
335 err = -ENOMEM;
336 goto __error;
337 }
338 data->entry = entry;
339 switch (entry->content) {
340 case SNDRV_INFO_CONTENT_TEXT:
341 if (mode == O_RDONLY || mode == O_RDWR) {
Takashi Iwaica2c0962005-09-09 14:20:23 +0200342 buffer = kzalloc(sizeof(*buffer), GFP_KERNEL);
Takashi Iwai7e4eeec2006-04-28 15:13:40 +0200343 if (buffer == NULL)
344 goto __nomem;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345 data->rbuffer = buffer;
Takashi Iwai7e4eeec2006-04-28 15:13:40 +0200346 buffer->len = PAGE_SIZE;
Takashi Iwai0d861ac2013-03-13 12:01:13 +0100347 buffer->buffer = kzalloc(buffer->len, GFP_KERNEL);
Takashi Iwai7e4eeec2006-04-28 15:13:40 +0200348 if (buffer->buffer == NULL)
349 goto __nomem;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350 }
351 if (mode == O_WRONLY || mode == O_RDWR) {
Takashi Iwaica2c0962005-09-09 14:20:23 +0200352 buffer = kzalloc(sizeof(*buffer), GFP_KERNEL);
Takashi Iwai7e4eeec2006-04-28 15:13:40 +0200353 if (buffer == NULL)
354 goto __nomem;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355 data->wbuffer = buffer;
Takashi Iwai7e4eeec2006-04-28 15:13:40 +0200356 buffer->len = PAGE_SIZE;
357 buffer->buffer = kmalloc(buffer->len, GFP_KERNEL);
358 if (buffer->buffer == NULL)
359 goto __nomem;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360 }
361 break;
362 case SNDRV_INFO_CONTENT_DATA: /* data */
363 if (entry->c.ops->open) {
364 if ((err = entry->c.ops->open(entry, mode,
365 &data->file_private_data)) < 0) {
366 kfree(data);
367 goto __error;
368 }
369 }
370 break;
371 }
372 file->private_data = data;
Ingo Molnar1a60d4c2006-01-16 16:29:08 +0100373 mutex_unlock(&info_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374 if (entry->content == SNDRV_INFO_CONTENT_TEXT &&
375 (mode == O_RDONLY || mode == O_RDWR)) {
376 if (entry->c.text.read) {
Ingo Molnar1a60d4c2006-01-16 16:29:08 +0100377 mutex_lock(&entry->access);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378 entry->c.text.read(entry, data->rbuffer);
Ingo Molnar1a60d4c2006-01-16 16:29:08 +0100379 mutex_unlock(&entry->access);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380 }
381 }
382 return 0;
383
Takashi Iwai7e4eeec2006-04-28 15:13:40 +0200384 __nomem:
385 if (data->rbuffer) {
386 kfree(data->rbuffer->buffer);
387 kfree(data->rbuffer);
388 }
389 if (data->wbuffer) {
390 kfree(data->wbuffer->buffer);
391 kfree(data->wbuffer);
392 }
393 kfree(data);
394 err = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395 __error:
396 module_put(entry->module);
397 __error1:
Ingo Molnar1a60d4c2006-01-16 16:29:08 +0100398 mutex_unlock(&info_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 return err;
400}
401
402static int snd_info_entry_release(struct inode *inode, struct file *file)
403{
Takashi Iwai24c1f932005-11-17 13:58:48 +0100404 struct snd_info_entry *entry;
405 struct snd_info_private_data *data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406 int mode;
407
408 mode = file->f_flags & O_ACCMODE;
409 data = file->private_data;
410 entry = data->entry;
411 switch (entry->content) {
412 case SNDRV_INFO_CONTENT_TEXT:
Takashi Iwai7e4eeec2006-04-28 15:13:40 +0200413 if (data->rbuffer) {
414 kfree(data->rbuffer->buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415 kfree(data->rbuffer);
416 }
Takashi Iwai7e4eeec2006-04-28 15:13:40 +0200417 if (data->wbuffer) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418 if (entry->c.text.write) {
419 entry->c.text.write(entry, data->wbuffer);
420 if (data->wbuffer->error) {
Takashi Iwaif2f93072014-02-04 18:21:03 +0100421 if (entry->card)
422 dev_warn(entry->card->dev, "info: data write error to %s (%i)\n",
423 entry->name,
424 data->wbuffer->error);
425 else
426 pr_warn("ALSA: info: data write error to %s (%i)\n",
427 entry->name,
428 data->wbuffer->error);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429 }
430 }
Takashi Iwai7e4eeec2006-04-28 15:13:40 +0200431 kfree(data->wbuffer->buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432 kfree(data->wbuffer);
433 }
434 break;
435 case SNDRV_INFO_CONTENT_DATA:
436 if (entry->c.ops->release)
437 entry->c.ops->release(entry, mode,
438 data->file_private_data);
439 break;
440 }
441 module_put(entry->module);
442 kfree(data);
443 return 0;
444}
445
446static unsigned int snd_info_entry_poll(struct file *file, poll_table * wait)
447{
Takashi Iwai24c1f932005-11-17 13:58:48 +0100448 struct snd_info_private_data *data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449 struct snd_info_entry *entry;
450 unsigned int mask;
451
452 data = file->private_data;
453 if (data == NULL)
454 return 0;
455 entry = data->entry;
456 mask = 0;
457 switch (entry->content) {
458 case SNDRV_INFO_CONTENT_DATA:
459 if (entry->c.ops->poll)
460 return entry->c.ops->poll(entry,
461 data->file_private_data,
462 file, wait);
463 if (entry->c.ops->read)
464 mask |= POLLIN | POLLRDNORM;
465 if (entry->c.ops->write)
466 mask |= POLLOUT | POLLWRNORM;
467 break;
468 }
469 return mask;
470}
471
Ingo Molnard99e9882006-01-09 16:44:46 +0100472static long snd_info_entry_ioctl(struct file *file, unsigned int cmd,
473 unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474{
Takashi Iwai24c1f932005-11-17 13:58:48 +0100475 struct snd_info_private_data *data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476 struct snd_info_entry *entry;
477
478 data = file->private_data;
479 if (data == NULL)
480 return 0;
481 entry = data->entry;
482 switch (entry->content) {
483 case SNDRV_INFO_CONTENT_DATA:
484 if (entry->c.ops->ioctl)
485 return entry->c.ops->ioctl(entry,
486 data->file_private_data,
487 file, cmd, arg);
488 break;
489 }
490 return -ENOTTY;
491}
492
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493static int snd_info_entry_mmap(struct file *file, struct vm_area_struct *vma)
494{
Al Viro496ad9a2013-01-23 17:07:38 -0500495 struct inode *inode = file_inode(file);
Takashi Iwai24c1f932005-11-17 13:58:48 +0100496 struct snd_info_private_data *data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497 struct snd_info_entry *entry;
498
499 data = file->private_data;
500 if (data == NULL)
501 return 0;
502 entry = data->entry;
503 switch (entry->content) {
504 case SNDRV_INFO_CONTENT_DATA:
505 if (entry->c.ops->mmap)
506 return entry->c.ops->mmap(entry,
507 data->file_private_data,
508 inode, file, vma);
509 break;
510 }
511 return -ENXIO;
512}
513
Arjan van de Ven9c2e08c2007-02-12 00:55:37 -0800514static const struct file_operations snd_info_entry_operations =
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515{
Ingo Molnard99e9882006-01-09 16:44:46 +0100516 .owner = THIS_MODULE,
517 .llseek = snd_info_entry_llseek,
518 .read = snd_info_entry_read,
519 .write = snd_info_entry_write,
520 .poll = snd_info_entry_poll,
521 .unlocked_ioctl = snd_info_entry_ioctl,
522 .mmap = snd_info_entry_mmap,
523 .open = snd_info_entry_open,
524 .release = snd_info_entry_release,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525};
526
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527int __init snd_info_init(void)
528{
529 struct proc_dir_entry *p;
530
Al Viroe55d92b2011-07-24 02:07:46 -0400531 p = proc_mkdir("asound", NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532 if (p == NULL)
533 return -ENOMEM;
534 snd_proc_root = p;
535#ifdef CONFIG_SND_OSSEMUL
536 {
Takashi Iwai24c1f932005-11-17 13:58:48 +0100537 struct snd_info_entry *entry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538 if ((entry = snd_info_create_module_entry(THIS_MODULE, "oss", NULL)) == NULL)
539 return -ENOMEM;
540 entry->mode = S_IFDIR | S_IRUGO | S_IXUGO;
541 if (snd_info_register(entry) < 0) {
542 snd_info_free_entry(entry);
543 return -ENOMEM;
544 }
545 snd_oss_root = entry;
546 }
547#endif
Takashi Iwai8eeaa2f2014-02-10 09:48:47 +0100548#if IS_ENABLED(CONFIG_SND_SEQUENCER)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549 {
Takashi Iwai24c1f932005-11-17 13:58:48 +0100550 struct snd_info_entry *entry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551 if ((entry = snd_info_create_module_entry(THIS_MODULE, "seq", NULL)) == NULL)
552 return -ENOMEM;
553 entry->mode = S_IFDIR | S_IRUGO | S_IXUGO;
554 if (snd_info_register(entry) < 0) {
555 snd_info_free_entry(entry);
556 return -ENOMEM;
557 }
558 snd_seq_root = entry;
559 }
560#endif
561 snd_info_version_init();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562 snd_minor_info_init();
563 snd_minor_info_oss_init();
564 snd_card_info_init();
565 return 0;
566}
567
568int __exit snd_info_done(void)
569{
570 snd_card_info_done();
571 snd_minor_info_oss_done();
572 snd_minor_info_done();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573 snd_info_version_done();
574 if (snd_proc_root) {
Takashi Iwai8eeaa2f2014-02-10 09:48:47 +0100575#if IS_ENABLED(CONFIG_SND_SEQUENCER)
Takashi Iwai746d4a02006-06-23 14:37:59 +0200576 snd_info_free_entry(snd_seq_root);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577#endif
578#ifdef CONFIG_SND_OSSEMUL
Takashi Iwai746d4a02006-06-23 14:37:59 +0200579 snd_info_free_entry(snd_oss_root);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580#endif
David Howellsa8ca16e2013-04-12 17:27:28 +0100581 proc_remove(snd_proc_root);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582 }
583 return 0;
584}
585
586/*
587
588 */
589
590
591/*
592 * create a card proc file
593 * called from init.c
594 */
Takashi Iwai24c1f932005-11-17 13:58:48 +0100595int snd_info_card_create(struct snd_card *card)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596{
597 char str[8];
Takashi Iwai24c1f932005-11-17 13:58:48 +0100598 struct snd_info_entry *entry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599
Takashi Iwai7eaa9432008-08-08 17:09:09 +0200600 if (snd_BUG_ON(!card))
601 return -ENXIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602
603 sprintf(str, "card%i", card->number);
604 if ((entry = snd_info_create_module_entry(card->module, str, NULL)) == NULL)
605 return -ENOMEM;
606 entry->mode = S_IFDIR | S_IRUGO | S_IXUGO;
607 if (snd_info_register(entry) < 0) {
608 snd_info_free_entry(entry);
609 return -ENOMEM;
610 }
611 card->proc_root = entry;
612 return 0;
613}
614
615/*
616 * register the card proc file
617 * called from init.c
618 */
Takashi Iwai24c1f932005-11-17 13:58:48 +0100619int snd_info_card_register(struct snd_card *card)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620{
621 struct proc_dir_entry *p;
622
Takashi Iwai7eaa9432008-08-08 17:09:09 +0200623 if (snd_BUG_ON(!card))
624 return -ENXIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625
626 if (!strcmp(card->id, card->proc_root->name))
627 return 0;
628
629 p = proc_symlink(card->id, snd_proc_root, card->proc_root->name);
630 if (p == NULL)
631 return -ENOMEM;
632 card->proc_root_link = p;
633 return 0;
634}
635
636/*
Jaroslav Kyselac2eb9c42008-11-12 16:31:37 +0100637 * called on card->id change
638 */
639void snd_info_card_id_change(struct snd_card *card)
640{
641 mutex_lock(&info_mutex);
642 if (card->proc_root_link) {
David Howellsa8ca16e2013-04-12 17:27:28 +0100643 proc_remove(card->proc_root_link);
Jaroslav Kyselac2eb9c42008-11-12 16:31:37 +0100644 card->proc_root_link = NULL;
645 }
646 if (strcmp(card->id, card->proc_root->name))
647 card->proc_root_link = proc_symlink(card->id,
648 snd_proc_root,
649 card->proc_root->name);
650 mutex_unlock(&info_mutex);
651}
652
653/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654 * de-register the card proc file
655 * called from init.c
656 */
Takashi Iwai746d4a02006-06-23 14:37:59 +0200657void snd_info_card_disconnect(struct snd_card *card)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658{
Takashi Iwai7eaa9432008-08-08 17:09:09 +0200659 if (!card)
660 return;
Takashi Iwai746d4a02006-06-23 14:37:59 +0200661 mutex_lock(&info_mutex);
David Howellsa8ca16e2013-04-12 17:27:28 +0100662 proc_remove(card->proc_root_link);
663 card->proc_root_link = NULL;
Takashi Iwai746d4a02006-06-23 14:37:59 +0200664 if (card->proc_root)
665 snd_info_disconnect(card->proc_root);
666 mutex_unlock(&info_mutex);
667}
668
669/*
670 * release the card proc file resources
671 * called from init.c
672 */
673int snd_info_card_free(struct snd_card *card)
674{
Takashi Iwai7eaa9432008-08-08 17:09:09 +0200675 if (!card)
676 return 0;
Takashi Iwai746d4a02006-06-23 14:37:59 +0200677 snd_info_free_entry(card->proc_root);
678 card->proc_root = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679 return 0;
680}
681
682
683/**
684 * snd_info_get_line - read one line from the procfs buffer
685 * @buffer: the procfs buffer
686 * @line: the buffer to store
687 * @len: the max. buffer size - 1
688 *
689 * Reads one line from the buffer and stores the string.
690 *
Yacine Belkadieb7c06e2013-03-11 22:05:14 +0100691 * Return: Zero if successful, or 1 if error or EOF.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700692 */
Takashi Iwai24c1f932005-11-17 13:58:48 +0100693int snd_info_get_line(struct snd_info_buffer *buffer, char *line, int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694{
695 int c = -1;
696
Takashi Iwai0bc0ec92013-03-13 12:11:13 +0100697 if (snd_BUG_ON(!buffer || !buffer->buffer))
698 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699 if (len <= 0 || buffer->stop || buffer->error)
700 return 1;
Takashi Iwai0bc0ec92013-03-13 12:11:13 +0100701 while (!buffer->stop) {
Takashi Iwai7e4eeec2006-04-28 15:13:40 +0200702 c = buffer->buffer[buffer->curr++];
703 if (buffer->curr >= buffer->size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704 buffer->stop = 1;
Takashi Iwai0bc0ec92013-03-13 12:11:13 +0100705 if (c == '\n')
706 break;
707 if (len) {
708 len--;
709 *line++ = c;
710 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711 }
712 *line = '\0';
713 return 0;
714}
715
Takashi Iwaic0d3fb32006-04-28 15:13:39 +0200716EXPORT_SYMBOL(snd_info_get_line);
717
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718/**
Henrik Kretzschmar856def82005-07-08 13:53:42 +0200719 * snd_info_get_str - parse a string token
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720 * @dest: the buffer to store the string token
721 * @src: the original string
722 * @len: the max. length of token - 1
723 *
724 * Parses the original string and copy a token to the given
725 * string buffer.
726 *
Yacine Belkadieb7c06e2013-03-11 22:05:14 +0100727 * Return: The updated pointer of the original string so that
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728 * it can be used for the next call.
729 */
Takashi Iwai4f7454a2009-09-08 14:29:58 +0200730const char *snd_info_get_str(char *dest, const char *src, int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731{
732 int c;
733
734 while (*src == ' ' || *src == '\t')
735 src++;
736 if (*src == '"' || *src == '\'') {
737 c = *src++;
738 while (--len > 0 && *src && *src != c) {
739 *dest++ = *src++;
740 }
741 if (*src == c)
742 src++;
743 } else {
744 while (--len > 0 && *src && *src != ' ' && *src != '\t') {
745 *dest++ = *src++;
746 }
747 }
748 *dest = 0;
749 while (*src == ' ' || *src == '\t')
750 src++;
751 return src;
752}
753
Takashi Iwaic0d3fb32006-04-28 15:13:39 +0200754EXPORT_SYMBOL(snd_info_get_str);
755
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756/**
757 * snd_info_create_entry - create an info entry
758 * @name: the proc file name
759 *
760 * Creates an info entry with the given file name and initializes as
761 * the default state.
762 *
763 * Usually called from other functions such as
764 * snd_info_create_card_entry().
765 *
Yacine Belkadieb7c06e2013-03-11 22:05:14 +0100766 * Return: The pointer of the new instance, or %NULL on failure.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700767 */
Takashi Iwai24c1f932005-11-17 13:58:48 +0100768static struct snd_info_entry *snd_info_create_entry(const char *name)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769{
Takashi Iwai24c1f932005-11-17 13:58:48 +0100770 struct snd_info_entry *entry;
Takashi Iwaica2c0962005-09-09 14:20:23 +0200771 entry = kzalloc(sizeof(*entry), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772 if (entry == NULL)
773 return NULL;
Paulo Marques543537b2005-06-23 00:09:02 -0700774 entry->name = kstrdup(name, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700775 if (entry->name == NULL) {
776 kfree(entry);
777 return NULL;
778 }
779 entry->mode = S_IFREG | S_IRUGO;
780 entry->content = SNDRV_INFO_CONTENT_TEXT;
Ingo Molnar1a60d4c2006-01-16 16:29:08 +0100781 mutex_init(&entry->access);
Takashi Iwai746d4a02006-06-23 14:37:59 +0200782 INIT_LIST_HEAD(&entry->children);
783 INIT_LIST_HEAD(&entry->list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784 return entry;
785}
786
787/**
788 * snd_info_create_module_entry - create an info entry for the given module
789 * @module: the module pointer
790 * @name: the file name
791 * @parent: the parent directory
792 *
793 * Creates a new info entry and assigns it to the given module.
794 *
Yacine Belkadieb7c06e2013-03-11 22:05:14 +0100795 * Return: The pointer of the new instance, or %NULL on failure.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796 */
Takashi Iwai24c1f932005-11-17 13:58:48 +0100797struct snd_info_entry *snd_info_create_module_entry(struct module * module,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798 const char *name,
Takashi Iwai24c1f932005-11-17 13:58:48 +0100799 struct snd_info_entry *parent)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700800{
Takashi Iwai24c1f932005-11-17 13:58:48 +0100801 struct snd_info_entry *entry = snd_info_create_entry(name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802 if (entry) {
803 entry->module = module;
804 entry->parent = parent;
805 }
806 return entry;
807}
808
Takashi Iwaic0d3fb32006-04-28 15:13:39 +0200809EXPORT_SYMBOL(snd_info_create_module_entry);
810
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811/**
812 * snd_info_create_card_entry - create an info entry for the given card
813 * @card: the card instance
814 * @name: the file name
815 * @parent: the parent directory
816 *
817 * Creates a new info entry and assigns it to the given card.
818 *
Yacine Belkadieb7c06e2013-03-11 22:05:14 +0100819 * Return: The pointer of the new instance, or %NULL on failure.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700820 */
Takashi Iwai24c1f932005-11-17 13:58:48 +0100821struct snd_info_entry *snd_info_create_card_entry(struct snd_card *card,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822 const char *name,
Takashi Iwai24c1f932005-11-17 13:58:48 +0100823 struct snd_info_entry * parent)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824{
Takashi Iwai24c1f932005-11-17 13:58:48 +0100825 struct snd_info_entry *entry = snd_info_create_entry(name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700826 if (entry) {
827 entry->module = card->module;
828 entry->card = card;
829 entry->parent = parent;
830 }
831 return entry;
832}
833
Takashi Iwaic0d3fb32006-04-28 15:13:39 +0200834EXPORT_SYMBOL(snd_info_create_card_entry);
835
Takashi Iwai746d4a02006-06-23 14:37:59 +0200836static void snd_info_disconnect(struct snd_info_entry *entry)
837{
838 struct list_head *p, *n;
839 struct proc_dir_entry *root;
840
841 list_for_each_safe(p, n, &entry->children) {
842 snd_info_disconnect(list_entry(p, struct snd_info_entry, list));
843 }
844
845 if (! entry->p)
846 return;
847 list_del_init(&entry->list);
848 root = entry->parent == NULL ? snd_proc_root : entry->parent->p;
Takashi Iwai7eaa9432008-08-08 17:09:09 +0200849 snd_BUG_ON(!root);
David Howellsa8ca16e2013-04-12 17:27:28 +0100850 proc_remove(entry->p);
Takashi Iwai746d4a02006-06-23 14:37:59 +0200851 entry->p = NULL;
852}
853
Takashi Iwai24c1f932005-11-17 13:58:48 +0100854static int snd_info_dev_free_entry(struct snd_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855{
Takashi Iwai24c1f932005-11-17 13:58:48 +0100856 struct snd_info_entry *entry = device->device_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700857 snd_info_free_entry(entry);
858 return 0;
859}
860
Takashi Iwai24c1f932005-11-17 13:58:48 +0100861static int snd_info_dev_register_entry(struct snd_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700862{
Takashi Iwai24c1f932005-11-17 13:58:48 +0100863 struct snd_info_entry *entry = device->device_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864 return snd_info_register(entry);
865}
866
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867/**
868 * snd_card_proc_new - create an info entry for the given card
869 * @card: the card instance
870 * @name: the file name
871 * @entryp: the pointer to store the new info entry
872 *
873 * Creates a new info entry and assigns it to the given card.
874 * Unlike snd_info_create_card_entry(), this function registers the
875 * info entry as an ALSA device component, so that it can be
876 * unregistered/released without explicit call.
877 * Also, you don't have to register this entry via snd_info_register(),
878 * since this will be registered by snd_card_register() automatically.
879 *
880 * The parent is assumed as card->proc_root.
881 *
882 * For releasing this entry, use snd_device_free() instead of
883 * snd_info_free_entry().
884 *
Yacine Belkadieb7c06e2013-03-11 22:05:14 +0100885 * Return: Zero if successful, or a negative error code on failure.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700886 */
Takashi Iwai24c1f932005-11-17 13:58:48 +0100887int snd_card_proc_new(struct snd_card *card, const char *name,
888 struct snd_info_entry **entryp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700889{
Takashi Iwai24c1f932005-11-17 13:58:48 +0100890 static struct snd_device_ops ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700891 .dev_free = snd_info_dev_free_entry,
892 .dev_register = snd_info_dev_register_entry,
Takashi Iwai746d4a02006-06-23 14:37:59 +0200893 /* disconnect is done via snd_info_card_disconnect() */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700894 };
Takashi Iwai24c1f932005-11-17 13:58:48 +0100895 struct snd_info_entry *entry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896 int err;
897
898 entry = snd_info_create_card_entry(card, name, card->proc_root);
899 if (! entry)
900 return -ENOMEM;
901 if ((err = snd_device_new(card, SNDRV_DEV_INFO, entry, &ops)) < 0) {
902 snd_info_free_entry(entry);
903 return err;
904 }
905 if (entryp)
906 *entryp = entry;
907 return 0;
908}
909
Takashi Iwaic0d3fb32006-04-28 15:13:39 +0200910EXPORT_SYMBOL(snd_card_proc_new);
911
Linus Torvalds1da177e2005-04-16 15:20:36 -0700912/**
913 * snd_info_free_entry - release the info entry
914 * @entry: the info entry
915 *
916 * Releases the info entry. Don't call this after registered.
917 */
Takashi Iwai24c1f932005-11-17 13:58:48 +0100918void snd_info_free_entry(struct snd_info_entry * entry)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700919{
920 if (entry == NULL)
921 return;
Takashi Iwai746d4a02006-06-23 14:37:59 +0200922 if (entry->p) {
923 mutex_lock(&info_mutex);
924 snd_info_disconnect(entry);
925 mutex_unlock(&info_mutex);
926 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927 kfree(entry->name);
928 if (entry->private_free)
929 entry->private_free(entry);
930 kfree(entry);
931}
932
Takashi Iwaic0d3fb32006-04-28 15:13:39 +0200933EXPORT_SYMBOL(snd_info_free_entry);
934
Linus Torvalds1da177e2005-04-16 15:20:36 -0700935/**
936 * snd_info_register - register the info entry
937 * @entry: the info entry
938 *
939 * Registers the proc info entry.
940 *
Yacine Belkadieb7c06e2013-03-11 22:05:14 +0100941 * Return: Zero if successful, or a negative error code on failure.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700942 */
Takashi Iwai24c1f932005-11-17 13:58:48 +0100943int snd_info_register(struct snd_info_entry * entry)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700944{
945 struct proc_dir_entry *root, *p = NULL;
946
Takashi Iwai7eaa9432008-08-08 17:09:09 +0200947 if (snd_BUG_ON(!entry))
948 return -ENXIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700949 root = entry->parent == NULL ? snd_proc_root : entry->parent->p;
Ingo Molnar1a60d4c2006-01-16 16:29:08 +0100950 mutex_lock(&info_mutex);
Al Viroaee0c612013-03-28 23:01:34 -0400951 if (S_ISDIR(entry->mode)) {
952 p = proc_mkdir_mode(entry->name, entry->mode, root);
953 if (!p) {
954 mutex_unlock(&info_mutex);
955 return -ENOMEM;
956 }
957 } else {
958 p = proc_create_data(entry->name, entry->mode, root,
959 &snd_info_entry_operations, entry);
960 if (!p) {
961 mutex_unlock(&info_mutex);
962 return -ENOMEM;
963 }
David Howells271a15e2013-04-12 00:38:51 +0100964 proc_set_size(p, entry->size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700965 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700966 entry->p = p;
Takashi Iwai746d4a02006-06-23 14:37:59 +0200967 if (entry->parent)
968 list_add_tail(&entry->list, &entry->parent->children);
Ingo Molnar1a60d4c2006-01-16 16:29:08 +0100969 mutex_unlock(&info_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700970 return 0;
971}
972
Takashi Iwaic0d3fb32006-04-28 15:13:39 +0200973EXPORT_SYMBOL(snd_info_register);
974
Linus Torvalds1da177e2005-04-16 15:20:36 -0700975/*
976
977 */
978
Takashi Iwai6581f4e2006-05-17 17:14:51 +0200979static struct snd_info_entry *snd_info_version_entry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700980
Takashi Iwai24c1f932005-11-17 13:58:48 +0100981static void snd_info_version_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700982{
983 snd_iprintf(buffer,
Jaroslav Kysela42662742012-09-04 11:21:45 +0200984 "Advanced Linux Sound Architecture Driver Version k%s.\n",
985 init_utsname()->release);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700986}
987
988static int __init snd_info_version_init(void)
989{
Takashi Iwai24c1f932005-11-17 13:58:48 +0100990 struct snd_info_entry *entry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700991
992 entry = snd_info_create_module_entry(THIS_MODULE, "version", NULL);
993 if (entry == NULL)
994 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700995 entry->c.text.read = snd_info_version_read;
996 if (snd_info_register(entry) < 0) {
997 snd_info_free_entry(entry);
998 return -ENOMEM;
999 }
1000 snd_info_version_entry = entry;
1001 return 0;
1002}
1003
1004static int __exit snd_info_version_done(void)
1005{
Takashi Iwai746d4a02006-06-23 14:37:59 +02001006 snd_info_free_entry(snd_info_version_entry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001007 return 0;
1008}
1009
1010#endif /* CONFIG_PROC_FS */