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