Branch data Line data Source code
1 : : /*
2 : : * Information interface for ALSA driver
3 : : * Copyright (c) by Jaroslav Kysela <perex@perex.cz>
4 : : *
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 : :
22 : : #include <linux/init.h>
23 : : #include <linux/time.h>
24 : : #include <linux/mm.h>
25 : : #include <linux/slab.h>
26 : : #include <linux/string.h>
27 : : #include <linux/module.h>
28 : : #include <sound/core.h>
29 : : #include <sound/minors.h>
30 : : #include <sound/info.h>
31 : : #include <linux/utsname.h>
32 : : #include <linux/proc_fs.h>
33 : : #include <linux/mutex.h>
34 : : #include <stdarg.h>
35 : :
36 : : /*
37 : : *
38 : : */
39 : :
40 : : #ifdef CONFIG_PROC_FS
41 : :
42 : 0 : int 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 [ # # ]: 0 : while (*xstr) {
62 [ # # ]: 0 : if (!strcmp(*xstr, str))
63 : : return 0;
64 : 0 : xstr++;
65 : : }
66 [ # # ]: 0 : if (!strncmp(str, "card", 4))
67 : : return 0;
68 : 0 : return 1;
69 : : }
70 : :
71 : : static DEFINE_MUTEX(info_mutex);
72 : :
73 : : struct snd_info_private_data {
74 : : struct snd_info_buffer *rbuffer;
75 : : struct snd_info_buffer *wbuffer;
76 : : struct snd_info_entry *entry;
77 : : void *file_private_data;
78 : : };
79 : :
80 : : static int snd_info_version_init(void);
81 : : static int snd_info_version_done(void);
82 : : static void snd_info_disconnect(struct snd_info_entry *entry);
83 : :
84 : :
85 : : /* resize the proc r/w buffer */
86 : 0 : static int resize_info_buffer(struct snd_info_buffer *buffer,
87 : : unsigned int nsize)
88 : : {
89 : : char *nbuf;
90 : :
91 : 0 : nsize = PAGE_ALIGN(nsize);
92 : 0 : nbuf = krealloc(buffer->buffer, nsize, GFP_KERNEL | __GFP_ZERO);
93 [ # # ]: 0 : if (! nbuf)
94 : : return -ENOMEM;
95 : :
96 : 0 : buffer->buffer = nbuf;
97 : 0 : buffer->len = nsize;
98 : : return 0;
99 : : }
100 : :
101 : : /**
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 : : *
108 : : * Return: The size of output string, or a negative error code.
109 : : */
110 : 0 : int snd_iprintf(struct snd_info_buffer *buffer, const char *fmt, ...)
111 : : {
112 : : va_list args;
113 : : int len, res;
114 : : int err = 0;
115 : :
116 : : might_sleep();
117 [ + - ][ + - ]: 157 : if (buffer->stop || buffer->error)
118 : : return 0;
119 : 157 : len = buffer->len - buffer->size;
120 : 157 : va_start(args, fmt);
121 : : for (;;) {
122 : : va_list ap;
123 : 157 : va_copy(ap, args);
124 : 157 : res = vsnprintf(buffer->buffer + buffer->curr, len, fmt, ap);
125 : 157 : va_end(ap);
126 [ - + ]: 157 : if (res < len)
127 : : break;
128 : 0 : err = resize_info_buffer(buffer, buffer->len + PAGE_SIZE);
129 [ # # ]: 0 : if (err < 0)
130 : : break;
131 : 0 : len = buffer->len - buffer->size;
132 : 0 : }
133 : 157 : va_end(args);
134 : :
135 [ + ]: 157 : if (err < 0)
136 : : return err;
137 : 157 : buffer->curr += res;
138 : 157 : buffer->size += res;
139 : 157 : return res;
140 : : }
141 : :
142 : : EXPORT_SYMBOL(snd_iprintf);
143 : :
144 : : /*
145 : :
146 : : */
147 : :
148 : : static struct proc_dir_entry *snd_proc_root;
149 : : struct snd_info_entry *snd_seq_root;
150 : : EXPORT_SYMBOL(snd_seq_root);
151 : :
152 : : #ifdef CONFIG_SND_OSSEMUL
153 : : struct snd_info_entry *snd_oss_root;
154 : : #endif
155 : :
156 : 0 : static loff_t snd_info_entry_llseek(struct file *file, loff_t offset, int orig)
157 : : {
158 : : struct snd_info_private_data *data;
159 : : struct snd_info_entry *entry;
160 : : loff_t ret = -EINVAL, size;
161 : :
162 : 0 : data = file->private_data;
163 : 0 : entry = data->entry;
164 : 0 : mutex_lock(&entry->access);
165 [ # # ][ # # ]: 0 : if (entry->content == SNDRV_INFO_CONTENT_DATA &&
166 : 0 : entry->c.ops->llseek) {
167 : 0 : offset = entry->c.ops->llseek(entry,
168 : : data->file_private_data,
169 : : file, offset, orig);
170 : 0 : goto out;
171 : : }
172 [ # # ]: 0 : if (entry->content == SNDRV_INFO_CONTENT_DATA)
173 : 0 : size = entry->size;
174 : : else
175 : : size = 0;
176 [ # # # # ]: 0 : switch (orig) {
177 : : case SEEK_SET:
178 : : break;
179 : : case SEEK_CUR:
180 : 0 : offset += file->f_pos;
181 : 0 : break;
182 : : case SEEK_END:
183 [ # # ]: 0 : if (!size)
184 : : goto out;
185 : 0 : offset += size;
186 : 0 : break;
187 : : default:
188 : : goto out;
189 : : }
190 [ # # ]: 0 : if (offset < 0)
191 : : goto out;
192 [ # # ]: 0 : if (size && offset > size)
193 : : offset = size;
194 : 0 : file->f_pos = offset;
195 : : ret = offset;
196 : : out:
197 : 0 : mutex_unlock(&entry->access);
198 : 0 : return ret;
199 : : }
200 : :
201 : 0 : static ssize_t snd_info_entry_read(struct file *file, char __user *buffer,
202 : : size_t count, loff_t * offset)
203 : : {
204 : : struct snd_info_private_data *data;
205 : : struct snd_info_entry *entry;
206 : : struct snd_info_buffer *buf;
207 : : size_t size = 0;
208 : : loff_t pos;
209 : :
210 : 44 : data = file->private_data;
211 [ + - ]: 44 : if (snd_BUG_ON(!data))
212 : : return -ENXIO;
213 : 44 : pos = *offset;
214 [ + - ][ + - ]: 44 : if (pos < 0 || (long) pos != pos || (ssize_t) count < 0)
[ + - ]
215 : : return -EIO;
216 [ + - ]: 44 : if ((unsigned long) pos + (unsigned long) count < (unsigned long) pos)
217 : : return -EIO;
218 : 44 : entry = data->entry;
219 [ + - - ]: 44 : switch (entry->content) {
220 : : case SNDRV_INFO_CONTENT_TEXT:
221 : 44 : buf = data->rbuffer;
222 [ + - ]: 44 : if (buf == NULL)
223 : : return -EIO;
224 [ + + ]: 44 : if (pos >= buf->size)
225 : : return 0;
226 : 22 : size = buf->size - pos;
227 : 22 : size = min(count, size);
228 [ + - ]: 66 : if (copy_to_user(buffer, buf->buffer + pos, size))
229 : : return -EFAULT;
230 : : break;
231 : : case SNDRV_INFO_CONTENT_DATA:
232 [ # # ]: 0 : if (pos >= entry->size)
233 : : return 0;
234 [ # # ]: 0 : if (entry->c.ops->read) {
235 : 0 : size = entry->size - pos;
236 : 0 : size = min(count, size);
237 : 0 : size = entry->c.ops->read(entry,
238 : : data->file_private_data,
239 : : file, buffer, size, pos);
240 : : }
241 : : break;
242 : : }
243 [ + - ]: 22 : if ((ssize_t) size > 0)
244 : 22 : *offset = pos + size;
245 : 22 : return size;
246 : : }
247 : :
248 : 0 : static ssize_t snd_info_entry_write(struct file *file, const char __user *buffer,
249 : : size_t count, loff_t * offset)
250 : : {
251 : : struct snd_info_private_data *data;
252 : : struct snd_info_entry *entry;
253 : : struct snd_info_buffer *buf;
254 : : ssize_t size = 0;
255 : : loff_t pos;
256 : :
257 : 0 : data = file->private_data;
258 [ # # ]: 0 : if (snd_BUG_ON(!data))
259 : : return -ENXIO;
260 : 0 : entry = data->entry;
261 : 0 : pos = *offset;
262 [ # # ][ # # ]: 0 : if (pos < 0 || (long) pos != pos || (ssize_t) count < 0)
[ # # ]
263 : : return -EIO;
264 [ # # ]: 0 : if ((unsigned long) pos + (unsigned long) count < (unsigned long) pos)
265 : : return -EIO;
266 [ # # # ]: 0 : switch (entry->content) {
267 : : case SNDRV_INFO_CONTENT_TEXT:
268 : 0 : buf = data->wbuffer;
269 [ # # ]: 0 : if (buf == NULL)
270 : : return -EIO;
271 : 0 : mutex_lock(&entry->access);
272 [ # # ]: 0 : if (pos + count >= buf->len) {
273 [ # # ]: 0 : if (resize_info_buffer(buf, pos + count)) {
274 : 0 : mutex_unlock(&entry->access);
275 : 0 : return -ENOMEM;
276 : : }
277 : : }
278 [ # # ]: 0 : if (copy_from_user(buf->buffer + pos, buffer, count)) {
279 : 0 : mutex_unlock(&entry->access);
280 : 0 : return -EFAULT;
281 : : }
282 : 0 : buf->size = pos + count;
283 : 0 : mutex_unlock(&entry->access);
284 : : size = count;
285 : 0 : break;
286 : : case SNDRV_INFO_CONTENT_DATA:
287 [ # # ][ # # ]: 0 : if (entry->c.ops->write && count > 0) {
288 : 0 : size_t maxsize = entry->size - pos;
289 : 0 : count = min(count, maxsize);
290 : 0 : size = entry->c.ops->write(entry,
291 : : data->file_private_data,
292 : : file, buffer, count, pos);
293 : : }
294 : : break;
295 : : }
296 [ # # ]: 0 : if ((ssize_t) size > 0)
297 : 0 : *offset = pos + size;
298 : 0 : return size;
299 : : }
300 : :
301 : 0 : static int snd_info_entry_open(struct inode *inode, struct file *file)
302 : : {
303 : : struct snd_info_entry *entry;
304 : : struct snd_info_private_data *data;
305 : : struct snd_info_buffer *buffer;
306 : : int mode, err;
307 : :
308 : 22 : mutex_lock(&info_mutex);
309 : 22 : entry = PDE_DATA(inode);
310 [ + - ][ - + ]: 22 : if (entry == NULL || ! entry->p) {
311 : 0 : mutex_unlock(&info_mutex);
312 : 0 : return -ENODEV;
313 : : }
314 [ + - ]: 22 : if (!try_module_get(entry->module)) {
315 : : err = -EFAULT;
316 : : goto __error1;
317 : : }
318 : 22 : mode = file->f_flags & O_ACCMODE;
319 [ + - ]: 22 : if (mode == O_RDONLY || mode == O_RDWR) {
320 [ - + ][ # # ]: 22 : if ((entry->content == SNDRV_INFO_CONTENT_DATA &&
321 : 0 : entry->c.ops->read == NULL)) {
322 : : err = -ENODEV;
323 : : goto __error;
324 : : }
325 : : }
326 [ - + ]: 22 : if (mode == O_WRONLY || mode == O_RDWR) {
327 [ # # ][ # # ]: 0 : if ((entry->content == SNDRV_INFO_CONTENT_DATA &&
328 : 0 : entry->c.ops->write == NULL)) {
329 : : err = -ENODEV;
330 : : goto __error;
331 : : }
332 : : }
333 : : data = kzalloc(sizeof(*data), GFP_KERNEL);
334 [ + - ]: 22 : if (data == NULL) {
335 : : err = -ENOMEM;
336 : : goto __error;
337 : : }
338 : 22 : data->entry = entry;
339 [ + - - ]: 22 : switch (entry->content) {
340 : : case SNDRV_INFO_CONTENT_TEXT:
341 [ + - ]: 22 : if (mode == O_RDONLY || mode == O_RDWR) {
342 : : buffer = kzalloc(sizeof(*buffer), GFP_KERNEL);
343 [ + - ]: 22 : if (buffer == NULL)
344 : : goto __nomem;
345 : 22 : data->rbuffer = buffer;
346 : 22 : buffer->len = PAGE_SIZE;
347 : 22 : buffer->buffer = kzalloc(buffer->len, GFP_KERNEL);
348 [ + - ]: 44 : if (buffer->buffer == NULL)
349 : : goto __nomem;
350 : : }
351 [ - + ]: 22 : if (mode == O_WRONLY || mode == O_RDWR) {
352 : : buffer = kzalloc(sizeof(*buffer), GFP_KERNEL);
353 [ # # ]: 0 : if (buffer == NULL)
354 : : goto __nomem;
355 : 0 : data->wbuffer = buffer;
356 : 0 : buffer->len = PAGE_SIZE;
357 : 0 : buffer->buffer = kmalloc(buffer->len, GFP_KERNEL);
358 [ # # ]: 0 : if (buffer->buffer == NULL)
359 : : goto __nomem;
360 : : }
361 : : break;
362 : : case SNDRV_INFO_CONTENT_DATA: /* data */
363 [ # # ]: 0 : if (entry->c.ops->open) {
364 [ # # ]: 0 : if ((err = entry->c.ops->open(entry, mode,
365 : : &data->file_private_data)) < 0) {
366 : 0 : kfree(data);
367 : 0 : goto __error;
368 : : }
369 : : }
370 : : break;
371 : : }
372 : 22 : file->private_data = data;
373 : 22 : mutex_unlock(&info_mutex);
374 [ + - ][ + - ]: 22 : if (entry->content == SNDRV_INFO_CONTENT_TEXT &&
375 : : (mode == O_RDONLY || mode == O_RDWR)) {
376 [ + - ]: 22 : if (entry->c.text.read) {
377 : 22 : mutex_lock(&entry->access);
378 : 22 : entry->c.text.read(entry, data->rbuffer);
379 : 22 : mutex_unlock(&entry->access);
380 : : }
381 : : }
382 : : return 0;
383 : :
384 : : __nomem:
385 [ # # ]: 0 : if (data->rbuffer) {
386 : 0 : kfree(data->rbuffer->buffer);
387 : 0 : kfree(data->rbuffer);
388 : : }
389 [ # # ]: 0 : if (data->wbuffer) {
390 : 0 : kfree(data->wbuffer->buffer);
391 : 0 : kfree(data->wbuffer);
392 : : }
393 : 0 : kfree(data);
394 : : err = -ENOMEM;
395 : : __error:
396 : 0 : module_put(entry->module);
397 : : __error1:
398 : 0 : mutex_unlock(&info_mutex);
399 : 0 : return err;
400 : : }
401 : :
402 : 0 : static int snd_info_entry_release(struct inode *inode, struct file *file)
403 : : {
404 : : struct snd_info_entry *entry;
405 : : struct snd_info_private_data *data;
406 : : int mode;
407 : :
408 : 22 : mode = file->f_flags & O_ACCMODE;
409 : 22 : data = file->private_data;
410 : 22 : entry = data->entry;
411 [ + - - ]: 22 : switch (entry->content) {
412 : : case SNDRV_INFO_CONTENT_TEXT:
413 [ + - ]: 22 : if (data->rbuffer) {
414 : 22 : kfree(data->rbuffer->buffer);
415 : 22 : kfree(data->rbuffer);
416 : : }
417 [ - + ]: 22 : if (data->wbuffer) {
418 [ # # ]: 0 : if (entry->c.text.write) {
419 : 0 : entry->c.text.write(entry, data->wbuffer);
420 [ # # ]: 0 : if (data->wbuffer->error) {
421 : 0 : snd_printk(KERN_WARNING "data write error to %s (%i)\n",
422 : : entry->name,
423 : : data->wbuffer->error);
424 : : }
425 : : }
426 : 0 : kfree(data->wbuffer->buffer);
427 : 0 : kfree(data->wbuffer);
428 : : }
429 : : break;
430 : : case SNDRV_INFO_CONTENT_DATA:
431 [ # # ]: 0 : if (entry->c.ops->release)
432 : 0 : entry->c.ops->release(entry, mode,
433 : : data->file_private_data);
434 : : break;
435 : : }
436 : 22 : module_put(entry->module);
437 : 22 : kfree(data);
438 : 22 : return 0;
439 : : }
440 : :
441 : 0 : static unsigned int snd_info_entry_poll(struct file *file, poll_table * wait)
442 : : {
443 : : struct snd_info_private_data *data;
444 : : struct snd_info_entry *entry;
445 : : unsigned int mask;
446 : :
447 : 0 : data = file->private_data;
448 [ # # ]: 0 : if (data == NULL)
449 : : return 0;
450 : 0 : entry = data->entry;
451 : : mask = 0;
452 [ # # ]: 0 : switch (entry->content) {
453 : : case SNDRV_INFO_CONTENT_DATA:
454 [ # # ]: 0 : if (entry->c.ops->poll)
455 : 0 : return entry->c.ops->poll(entry,
456 : : data->file_private_data,
457 : : file, wait);
458 [ # # ]: 0 : if (entry->c.ops->read)
459 : : mask |= POLLIN | POLLRDNORM;
460 [ # # ]: 0 : if (entry->c.ops->write)
461 : 0 : mask |= POLLOUT | POLLWRNORM;
462 : : break;
463 : : }
464 : 0 : return mask;
465 : : }
466 : :
467 : 0 : static long snd_info_entry_ioctl(struct file *file, unsigned int cmd,
468 : : unsigned long arg)
469 : : {
470 : : struct snd_info_private_data *data;
471 : : struct snd_info_entry *entry;
472 : :
473 : 0 : data = file->private_data;
474 [ # # ]: 0 : if (data == NULL)
475 : : return 0;
476 : 0 : entry = data->entry;
477 [ # # ]: 0 : switch (entry->content) {
478 : : case SNDRV_INFO_CONTENT_DATA:
479 [ # # ]: 0 : if (entry->c.ops->ioctl)
480 : 0 : return entry->c.ops->ioctl(entry,
481 : : data->file_private_data,
482 : : file, cmd, arg);
483 : : break;
484 : : }
485 : : return -ENOTTY;
486 : : }
487 : :
488 : 0 : static int snd_info_entry_mmap(struct file *file, struct vm_area_struct *vma)
489 : : {
490 : : struct inode *inode = file_inode(file);
491 : : struct snd_info_private_data *data;
492 : : struct snd_info_entry *entry;
493 : :
494 : 0 : data = file->private_data;
495 [ # # ]: 0 : if (data == NULL)
496 : : return 0;
497 : 0 : entry = data->entry;
498 [ # # ]: 0 : switch (entry->content) {
499 : : case SNDRV_INFO_CONTENT_DATA:
500 [ # # ]: 0 : if (entry->c.ops->mmap)
501 : 0 : return entry->c.ops->mmap(entry,
502 : : data->file_private_data,
503 : : inode, file, vma);
504 : : break;
505 : : }
506 : : return -ENXIO;
507 : : }
508 : :
509 : : static const struct file_operations snd_info_entry_operations =
510 : : {
511 : : .owner = THIS_MODULE,
512 : : .llseek = snd_info_entry_llseek,
513 : : .read = snd_info_entry_read,
514 : : .write = snd_info_entry_write,
515 : : .poll = snd_info_entry_poll,
516 : : .unlocked_ioctl = snd_info_entry_ioctl,
517 : : .mmap = snd_info_entry_mmap,
518 : : .open = snd_info_entry_open,
519 : : .release = snd_info_entry_release,
520 : : };
521 : :
522 : 0 : int __init snd_info_init(void)
523 : : {
524 : : struct proc_dir_entry *p;
525 : :
526 : 0 : p = proc_mkdir("asound", NULL);
527 [ # # ]: 0 : if (p == NULL)
528 : : return -ENOMEM;
529 : 0 : snd_proc_root = p;
530 : : #ifdef CONFIG_SND_OSSEMUL
531 : : {
532 : : struct snd_info_entry *entry;
533 : : if ((entry = snd_info_create_module_entry(THIS_MODULE, "oss", NULL)) == NULL)
534 : : return -ENOMEM;
535 : : entry->mode = S_IFDIR | S_IRUGO | S_IXUGO;
536 : : if (snd_info_register(entry) < 0) {
537 : : snd_info_free_entry(entry);
538 : : return -ENOMEM;
539 : : }
540 : : snd_oss_root = entry;
541 : : }
542 : : #endif
543 : : #if defined(CONFIG_SND_SEQUENCER) || defined(CONFIG_SND_SEQUENCER_MODULE)
544 : : {
545 : : struct snd_info_entry *entry;
546 : : if ((entry = snd_info_create_module_entry(THIS_MODULE, "seq", NULL)) == NULL)
547 : : return -ENOMEM;
548 : : entry->mode = S_IFDIR | S_IRUGO | S_IXUGO;
549 : : if (snd_info_register(entry) < 0) {
550 : : snd_info_free_entry(entry);
551 : : return -ENOMEM;
552 : : }
553 : : snd_seq_root = entry;
554 : : }
555 : : #endif
556 : 0 : snd_info_version_init();
557 : 0 : snd_minor_info_init();
558 : : snd_minor_info_oss_init();
559 : 0 : snd_card_info_init();
560 : 0 : return 0;
561 : : }
562 : :
563 : 0 : int __exit snd_info_done(void)
564 : : {
565 : 0 : snd_card_info_done();
566 : : snd_minor_info_oss_done();
567 : 0 : snd_minor_info_done();
568 : 0 : snd_info_version_done();
569 [ # # ]: 0 : if (snd_proc_root) {
570 : : #if defined(CONFIG_SND_SEQUENCER) || defined(CONFIG_SND_SEQUENCER_MODULE)
571 : : snd_info_free_entry(snd_seq_root);
572 : : #endif
573 : : #ifdef CONFIG_SND_OSSEMUL
574 : : snd_info_free_entry(snd_oss_root);
575 : : #endif
576 : 0 : proc_remove(snd_proc_root);
577 : : }
578 : 0 : return 0;
579 : : }
580 : :
581 : : /*
582 : :
583 : : */
584 : :
585 : :
586 : : /*
587 : : * create a card proc file
588 : : * called from init.c
589 : : */
590 : 0 : int snd_info_card_create(struct snd_card *card)
591 : : {
592 : : char str[8];
593 : : struct snd_info_entry *entry;
594 : :
595 [ # # ]: 0 : if (snd_BUG_ON(!card))
596 : : return -ENXIO;
597 : :
598 : 0 : sprintf(str, "card%i", card->number);
599 [ # # ]: 0 : if ((entry = snd_info_create_module_entry(card->module, str, NULL)) == NULL)
600 : : return -ENOMEM;
601 : 0 : entry->mode = S_IFDIR | S_IRUGO | S_IXUGO;
602 [ # # ]: 0 : if (snd_info_register(entry) < 0) {
603 : 0 : snd_info_free_entry(entry);
604 : 0 : return -ENOMEM;
605 : : }
606 : 0 : card->proc_root = entry;
607 : 0 : return 0;
608 : : }
609 : :
610 : : /*
611 : : * register the card proc file
612 : : * called from init.c
613 : : */
614 : 0 : int snd_info_card_register(struct snd_card *card)
615 : : {
616 : : struct proc_dir_entry *p;
617 : :
618 [ # # ]: 0 : if (snd_BUG_ON(!card))
619 : : return -ENXIO;
620 : :
621 [ # # ]: 0 : if (!strcmp(card->id, card->proc_root->name))
622 : : return 0;
623 : :
624 : 0 : p = proc_symlink(card->id, snd_proc_root, card->proc_root->name);
625 [ # # ]: 0 : if (p == NULL)
626 : : return -ENOMEM;
627 : 0 : card->proc_root_link = p;
628 : 0 : return 0;
629 : : }
630 : :
631 : : /*
632 : : * called on card->id change
633 : : */
634 : 0 : void snd_info_card_id_change(struct snd_card *card)
635 : : {
636 : 0 : mutex_lock(&info_mutex);
637 [ # # ]: 0 : if (card->proc_root_link) {
638 : 0 : proc_remove(card->proc_root_link);
639 : 0 : card->proc_root_link = NULL;
640 : : }
641 [ # # ]: 0 : if (strcmp(card->id, card->proc_root->name))
642 : 0 : card->proc_root_link = proc_symlink(card->id,
643 : : snd_proc_root,
644 : : card->proc_root->name);
645 : 0 : mutex_unlock(&info_mutex);
646 : 0 : }
647 : :
648 : : /*
649 : : * de-register the card proc file
650 : : * called from init.c
651 : : */
652 : 0 : void snd_info_card_disconnect(struct snd_card *card)
653 : : {
654 [ # # ]: 0 : if (!card)
655 : 0 : return;
656 : 0 : mutex_lock(&info_mutex);
657 : 0 : proc_remove(card->proc_root_link);
658 : 0 : card->proc_root_link = NULL;
659 [ # # ]: 0 : if (card->proc_root)
660 : 0 : snd_info_disconnect(card->proc_root);
661 : 0 : mutex_unlock(&info_mutex);
662 : : }
663 : :
664 : : /*
665 : : * release the card proc file resources
666 : : * called from init.c
667 : : */
668 : 0 : int snd_info_card_free(struct snd_card *card)
669 : : {
670 [ # # ]: 0 : if (!card)
671 : : return 0;
672 : 0 : snd_info_free_entry(card->proc_root);
673 : 0 : card->proc_root = NULL;
674 : 0 : return 0;
675 : : }
676 : :
677 : :
678 : : /**
679 : : * snd_info_get_line - read one line from the procfs buffer
680 : : * @buffer: the procfs buffer
681 : : * @line: the buffer to store
682 : : * @len: the max. buffer size - 1
683 : : *
684 : : * Reads one line from the buffer and stores the string.
685 : : *
686 : : * Return: Zero if successful, or 1 if error or EOF.
687 : : */
688 : 0 : int snd_info_get_line(struct snd_info_buffer *buffer, char *line, int len)
689 : : {
690 : : int c = -1;
691 : :
692 [ # # ][ # # ]: 0 : if (snd_BUG_ON(!buffer || !buffer->buffer))
[ # # ]
693 : : return 1;
694 [ # # ][ # # ]: 0 : if (len <= 0 || buffer->stop || buffer->error)
[ # # ]
695 : : return 1;
696 [ # # ]: 0 : while (!buffer->stop) {
697 : 0 : c = buffer->buffer[buffer->curr++];
698 [ # # ]: 0 : if (buffer->curr >= buffer->size)
699 : 0 : buffer->stop = 1;
700 [ # # ]: 0 : if (c == '\n')
701 : : break;
702 [ # # ]: 0 : if (len) {
703 : 0 : len--;
704 : 0 : *line++ = c;
705 : : }
706 : : }
707 : 0 : *line = '\0';
708 : 0 : return 0;
709 : : }
710 : :
711 : : EXPORT_SYMBOL(snd_info_get_line);
712 : :
713 : : /**
714 : : * snd_info_get_str - parse a string token
715 : : * @dest: the buffer to store the string token
716 : : * @src: the original string
717 : : * @len: the max. length of token - 1
718 : : *
719 : : * Parses the original string and copy a token to the given
720 : : * string buffer.
721 : : *
722 : : * Return: The updated pointer of the original string so that
723 : : * it can be used for the next call.
724 : : */
725 : 0 : const char *snd_info_get_str(char *dest, const char *src, int len)
726 : : {
727 : : int c;
728 : :
729 [ # # ]: 0 : while (*src == ' ' || *src == '\t')
730 : 0 : src++;
731 [ # # ]: 0 : if (*src == '"' || *src == '\'') {
732 : 0 : c = *src++;
733 [ # # ][ # # ]: 0 : while (--len > 0 && *src && *src != c) {
[ # # ]
734 : 0 : *dest++ = *src++;
735 : : }
736 [ # # ]: 0 : if (*src == c)
737 : 0 : src++;
738 : : } else {
739 [ # # ][ # # ]: 0 : while (--len > 0 && *src && *src != ' ' && *src != '\t') {
[ # # ][ # # ]
740 : 0 : *dest++ = *src++;
741 : : }
742 : : }
743 : 0 : *dest = 0;
744 [ # # ]: 0 : while (*src == ' ' || *src == '\t')
745 : 0 : src++;
746 : 0 : return src;
747 : : }
748 : :
749 : : EXPORT_SYMBOL(snd_info_get_str);
750 : :
751 : : /**
752 : : * snd_info_create_entry - create an info entry
753 : : * @name: the proc file name
754 : : *
755 : : * Creates an info entry with the given file name and initializes as
756 : : * the default state.
757 : : *
758 : : * Usually called from other functions such as
759 : : * snd_info_create_card_entry().
760 : : *
761 : : * Return: The pointer of the new instance, or %NULL on failure.
762 : : */
763 : 0 : static struct snd_info_entry *snd_info_create_entry(const char *name)
764 : : {
765 : : struct snd_info_entry *entry;
766 : : entry = kzalloc(sizeof(*entry), GFP_KERNEL);
767 [ # # ]: 0 : if (entry == NULL)
768 : : return NULL;
769 : 0 : entry->name = kstrdup(name, GFP_KERNEL);
770 [ # # ]: 0 : if (entry->name == NULL) {
771 : 0 : kfree(entry);
772 : 0 : return NULL;
773 : : }
774 : 0 : entry->mode = S_IFREG | S_IRUGO;
775 : 0 : entry->content = SNDRV_INFO_CONTENT_TEXT;
776 : 0 : mutex_init(&entry->access);
777 : 0 : INIT_LIST_HEAD(&entry->children);
778 : 0 : INIT_LIST_HEAD(&entry->list);
779 : 0 : return entry;
780 : : }
781 : :
782 : : /**
783 : : * snd_info_create_module_entry - create an info entry for the given module
784 : : * @module: the module pointer
785 : : * @name: the file name
786 : : * @parent: the parent directory
787 : : *
788 : : * Creates a new info entry and assigns it to the given module.
789 : : *
790 : : * Return: The pointer of the new instance, or %NULL on failure.
791 : : */
792 : 0 : struct snd_info_entry *snd_info_create_module_entry(struct module * module,
793 : : const char *name,
794 : : struct snd_info_entry *parent)
795 : : {
796 : 0 : struct snd_info_entry *entry = snd_info_create_entry(name);
797 [ # # # # : 0 : if (entry) {
# # ]
798 : 0 : entry->module = module;
799 : 0 : entry->parent = parent;
800 : : }
801 : 0 : return entry;
802 : : }
803 : :
804 : : EXPORT_SYMBOL(snd_info_create_module_entry);
805 : :
806 : : /**
807 : : * snd_info_create_card_entry - create an info entry for the given card
808 : : * @card: the card instance
809 : : * @name: the file name
810 : : * @parent: the parent directory
811 : : *
812 : : * Creates a new info entry and assigns it to the given card.
813 : : *
814 : : * Return: The pointer of the new instance, or %NULL on failure.
815 : : */
816 : 0 : struct snd_info_entry *snd_info_create_card_entry(struct snd_card *card,
817 : : const char *name,
818 : : struct snd_info_entry * parent)
819 : : {
820 : 0 : struct snd_info_entry *entry = snd_info_create_entry(name);
821 [ # # # # ]: 0 : if (entry) {
822 : 0 : entry->module = card->module;
823 : 0 : entry->card = card;
824 : 0 : entry->parent = parent;
825 : : }
826 : 0 : return entry;
827 : : }
828 : :
829 : : EXPORT_SYMBOL(snd_info_create_card_entry);
830 : :
831 : 0 : static void snd_info_disconnect(struct snd_info_entry *entry)
832 : : {
833 : : struct list_head *p, *n;
834 : : struct proc_dir_entry *root;
835 : :
836 [ # # ]: 0 : list_for_each_safe(p, n, &entry->children) {
837 : 0 : snd_info_disconnect(list_entry(p, struct snd_info_entry, list));
838 : : }
839 : :
840 [ # # ]: 0 : if (! entry->p)
841 : 0 : return;
842 : 0 : list_del_init(&entry->list);
843 : : root = entry->parent == NULL ? snd_proc_root : entry->parent->p;
844 : : snd_BUG_ON(!root);
845 : 0 : proc_remove(entry->p);
846 : 0 : entry->p = NULL;
847 : : }
848 : :
849 : 0 : static int snd_info_dev_free_entry(struct snd_device *device)
850 : : {
851 : 0 : struct snd_info_entry *entry = device->device_data;
852 : 0 : snd_info_free_entry(entry);
853 : 0 : return 0;
854 : : }
855 : :
856 : 0 : static int snd_info_dev_register_entry(struct snd_device *device)
857 : : {
858 : 0 : struct snd_info_entry *entry = device->device_data;
859 : 0 : return snd_info_register(entry);
860 : : }
861 : :
862 : : /**
863 : : * snd_card_proc_new - create an info entry for the given card
864 : : * @card: the card instance
865 : : * @name: the file name
866 : : * @entryp: the pointer to store the new info entry
867 : : *
868 : : * Creates a new info entry and assigns it to the given card.
869 : : * Unlike snd_info_create_card_entry(), this function registers the
870 : : * info entry as an ALSA device component, so that it can be
871 : : * unregistered/released without explicit call.
872 : : * Also, you don't have to register this entry via snd_info_register(),
873 : : * since this will be registered by snd_card_register() automatically.
874 : : *
875 : : * The parent is assumed as card->proc_root.
876 : : *
877 : : * For releasing this entry, use snd_device_free() instead of
878 : : * snd_info_free_entry().
879 : : *
880 : : * Return: Zero if successful, or a negative error code on failure.
881 : : */
882 : 0 : int snd_card_proc_new(struct snd_card *card, const char *name,
883 : : struct snd_info_entry **entryp)
884 : : {
885 : : static struct snd_device_ops ops = {
886 : : .dev_free = snd_info_dev_free_entry,
887 : : .dev_register = snd_info_dev_register_entry,
888 : : /* disconnect is done via snd_info_card_disconnect() */
889 : : };
890 : : struct snd_info_entry *entry;
891 : : int err;
892 : :
893 : 0 : entry = snd_info_create_card_entry(card, name, card->proc_root);
894 [ # # ]: 0 : if (! entry)
895 : : return -ENOMEM;
896 [ # # ]: 0 : if ((err = snd_device_new(card, SNDRV_DEV_INFO, entry, &ops)) < 0) {
897 : 0 : snd_info_free_entry(entry);
898 : 0 : return err;
899 : : }
900 [ # # ]: 0 : if (entryp)
901 : 0 : *entryp = entry;
902 : : return 0;
903 : : }
904 : :
905 : : EXPORT_SYMBOL(snd_card_proc_new);
906 : :
907 : : /**
908 : : * snd_info_free_entry - release the info entry
909 : : * @entry: the info entry
910 : : *
911 : : * Releases the info entry. Don't call this after registered.
912 : : */
913 : 0 : void snd_info_free_entry(struct snd_info_entry * entry)
914 : : {
915 [ # # ]: 0 : if (entry == NULL)
916 : 0 : return;
917 [ # # ]: 0 : if (entry->p) {
918 : 0 : mutex_lock(&info_mutex);
919 : 0 : snd_info_disconnect(entry);
920 : 0 : mutex_unlock(&info_mutex);
921 : : }
922 : 0 : kfree(entry->name);
923 [ # # ]: 0 : if (entry->private_free)
924 : 0 : entry->private_free(entry);
925 : 0 : kfree(entry);
926 : : }
927 : :
928 : : EXPORT_SYMBOL(snd_info_free_entry);
929 : :
930 : : /**
931 : : * snd_info_register - register the info entry
932 : : * @entry: the info entry
933 : : *
934 : : * Registers the proc info entry.
935 : : *
936 : : * Return: Zero if successful, or a negative error code on failure.
937 : : */
938 : 0 : int snd_info_register(struct snd_info_entry * entry)
939 : : {
940 : : struct proc_dir_entry *root, *p = NULL;
941 : :
942 [ # # ]: 0 : if (snd_BUG_ON(!entry))
943 : : return -ENXIO;
944 [ # # ]: 0 : root = entry->parent == NULL ? snd_proc_root : entry->parent->p;
945 : 0 : mutex_lock(&info_mutex);
946 [ # # ]: 0 : if (S_ISDIR(entry->mode)) {
947 : 0 : p = proc_mkdir_mode(entry->name, entry->mode, root);
948 [ # # ]: 0 : if (!p) {
949 : 0 : mutex_unlock(&info_mutex);
950 : 0 : return -ENOMEM;
951 : : }
952 : : } else {
953 : 0 : p = proc_create_data(entry->name, entry->mode, root,
954 : : &snd_info_entry_operations, entry);
955 [ # # ]: 0 : if (!p) {
956 : 0 : mutex_unlock(&info_mutex);
957 : 0 : return -ENOMEM;
958 : : }
959 : 0 : proc_set_size(p, entry->size);
960 : : }
961 : 0 : entry->p = p;
962 [ # # ]: 0 : if (entry->parent)
963 : 0 : list_add_tail(&entry->list, &entry->parent->children);
964 : 0 : mutex_unlock(&info_mutex);
965 : 0 : return 0;
966 : : }
967 : :
968 : : EXPORT_SYMBOL(snd_info_register);
969 : :
970 : : /*
971 : :
972 : : */
973 : :
974 : : static struct snd_info_entry *snd_info_version_entry;
975 : :
976 : 0 : static void snd_info_version_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer)
977 : : {
978 : 1 : snd_iprintf(buffer,
979 : : "Advanced Linux Sound Architecture Driver Version k%s.\n",
980 : : init_utsname()->release);
981 : 1 : }
982 : :
983 : 0 : static int __init snd_info_version_init(void)
984 : : {
985 : : struct snd_info_entry *entry;
986 : :
987 : : entry = snd_info_create_module_entry(THIS_MODULE, "version", NULL);
988 [ # # ]: 0 : if (entry == NULL)
989 : : return -ENOMEM;
990 : 0 : entry->c.text.read = snd_info_version_read;
991 [ # # ]: 0 : if (snd_info_register(entry) < 0) {
992 : 0 : snd_info_free_entry(entry);
993 : 0 : return -ENOMEM;
994 : : }
995 : 0 : snd_info_version_entry = entry;
996 : 0 : return 0;
997 : : }
998 : :
999 : 0 : static int __exit snd_info_version_done(void)
1000 : : {
1001 : 0 : snd_info_free_entry(snd_info_version_entry);
1002 : 0 : return 0;
1003 : : }
1004 : :
1005 : : #endif /* CONFIG_PROC_FS */
|
