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