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 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 | __GFP_ZERO); 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 * Return: The size of output string, or a negative error code. 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 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 data = file->private_data; 163 entry = data->entry; 164 mutex_lock(&entry->access); 165 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; 171 } 172 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: 197 mutex_unlock(&entry->access); 198 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{ 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 data = file->private_data; 211 if (snd_BUG_ON(!data)) 212 return -ENXIO; 213 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: 232 if (pos >= entry->size) 233 return 0; 234 if (entry->c.ops->read) { 235 size = entry->size - pos; 236 size = min(count, size); 237 size = entry->c.ops->read(entry, 238 data->file_private_data, 239 file, buffer, size, pos); 240 } 241 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{ 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 data = file->private_data; 258 if (snd_BUG_ON(!data)) 259 return -ENXIO; 260 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; 271 mutex_lock(&entry->access); 272 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); 280 return -EFAULT; 281 } 282 buf->size = pos + count; 283 mutex_unlock(&entry->access); 284 size = count; 285 break; 286 case SNDRV_INFO_CONTENT_DATA: 287 if (entry->c.ops->write && count > 0) { 288 size_t maxsize = entry->size - pos; 289 count = min(count, maxsize); 290 size = entry->c.ops->write(entry, 291 data->file_private_data, 292 file, buffer, count, pos); 293 } 294 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{ 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 mutex_lock(&info_mutex); 309 entry = PDE_DATA(inode); 310 if (entry == NULL || ! entry->p) { 311 mutex_unlock(&info_mutex); 312 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) { 320 if ((entry->content == SNDRV_INFO_CONTENT_DATA && 321 entry->c.ops->read == NULL)) { 322 err = -ENODEV; 323 goto __error; 324 } 325 } 326 if (mode == O_WRONLY || mode == O_RDWR) { 327 if ((entry->content == SNDRV_INFO_CONTENT_DATA && 328 entry->c.ops->write == NULL)) { 329 err = -ENODEV; 330 goto __error; 331 } 332 } 333 data = kzalloc(sizeof(*data), GFP_KERNEL); 334 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) { 342 buffer = kzalloc(sizeof(*buffer), GFP_KERNEL); 343 if (buffer == NULL) 344 goto __nomem; 345 data->rbuffer = buffer; 346 buffer->len = PAGE_SIZE; 347 buffer->buffer = kzalloc(buffer->len, GFP_KERNEL); 348 if (buffer->buffer == NULL) 349 goto __nomem; 350 } 351 if (mode == O_WRONLY || mode == O_RDWR) { 352 buffer = kzalloc(sizeof(*buffer), GFP_KERNEL); 353 if (buffer == NULL) 354 goto __nomem; 355 data->wbuffer = buffer; 356 buffer->len = PAGE_SIZE; 357 buffer->buffer = kmalloc(buffer->len, GFP_KERNEL); 358 if (buffer->buffer == NULL) 359 goto __nomem; 360 } 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; 373 mutex_unlock(&info_mutex); 374 if (entry->content == SNDRV_INFO_CONTENT_TEXT && 375 (mode == O_RDONLY || mode == O_RDWR)) { 376 if (entry->c.text.read) { 377 mutex_lock(&entry->access); 378 entry->c.text.read(entry, data->rbuffer); 379 mutex_unlock(&entry->access); 380 } 381 } 382 return 0; 383 384 __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; 395 __error: 396 module_put(entry->module); 397 __error1: 398 mutex_unlock(&info_mutex); 399 return err; 400} 401 402static 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 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: 413 if (data->rbuffer) { 414 kfree(data->rbuffer->buffer); 415 kfree(data->rbuffer); 416 } 417 if (data->wbuffer) { 418 if (entry->c.text.write) { 419 entry->c.text.write(entry, data->wbuffer); 420 if (data->wbuffer->error) { 421 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); 429 } 430 } 431 kfree(data->wbuffer->buffer); 432 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{ 448 struct snd_info_private_data *data; 449 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 472static long snd_info_entry_ioctl(struct file *file, unsigned int cmd, 473 unsigned long arg) 474{ 475 struct snd_info_private_data *data; 476 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 493static int snd_info_entry_mmap(struct file *file, struct vm_area_struct *vma) 494{ 495 struct inode *inode = file_inode(file); 496 struct snd_info_private_data *data; 497 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 514static const struct file_operations snd_info_entry_operations = 515{ 516 .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, 525}; 526 527int __init snd_info_init(void) 528{ 529 struct proc_dir_entry *p; 530 531 p = proc_mkdir("asound", NULL); 532 if (p == NULL) 533 return -ENOMEM; 534 snd_proc_root = p; 535#ifdef CONFIG_SND_OSSEMUL 536 { 537 struct snd_info_entry *entry; 538 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 548#if IS_ENABLED(CONFIG_SND_SEQUENCER) 549 { 550 struct snd_info_entry *entry; 551 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(); 562 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(); 573 snd_info_version_done(); 574 if (snd_proc_root) { 575#if IS_ENABLED(CONFIG_SND_SEQUENCER) 576 snd_info_free_entry(snd_seq_root); 577#endif 578#ifdef CONFIG_SND_OSSEMUL 579 snd_info_free_entry(snd_oss_root); 580#endif 581 proc_remove(snd_proc_root); 582 } 583 return 0; 584} 585 586/* 587 588 */ 589 590 591/* 592 * create a card proc file 593 * called from init.c 594 */ 595int snd_info_card_create(struct snd_card *card) 596{ 597 char str[8]; 598 struct snd_info_entry *entry; 599 600 if (snd_BUG_ON(!card)) 601 return -ENXIO; 602 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 */ 619int snd_info_card_register(struct snd_card *card) 620{ 621 struct proc_dir_entry *p; 622 623 if (snd_BUG_ON(!card)) 624 return -ENXIO; 625 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/* 637 * 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) { 643 proc_remove(card->proc_root_link); 644 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/* 654 * de-register the card proc file 655 * called from init.c 656 */ 657void snd_info_card_disconnect(struct snd_card *card) 658{ 659 if (!card) 660 return; 661 mutex_lock(&info_mutex); 662 proc_remove(card->proc_root_link); 663 card->proc_root_link = NULL; 664 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{ 675 if (!card) 676 return 0; 677 snd_info_free_entry(card->proc_root); 678 card->proc_root = NULL; 679 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 688 * 689 * Reads one line from the buffer and stores the string. 690 * 691 * Return: Zero if successful, or 1 if error or EOF. 692 */ 693int snd_info_get_line(struct snd_info_buffer *buffer, char *line, int len) 694{ 695 int c = -1; 696 697 if (snd_BUG_ON(!buffer || !buffer->buffer)) 698 return 1; 699 if (len <= 0 || buffer->stop || buffer->error) 700 return 1; 701 while (!buffer->stop) { 702 c = buffer->buffer[buffer->curr++]; 703 if (buffer->curr >= buffer->size) 704 buffer->stop = 1; 705 if (c == '\n') 706 break; 707 if (len > 1) { 708 len--; 709 *line++ = c; 710 } 711 } 712 *line = '\0'; 713 return 0; 714} 715 716EXPORT_SYMBOL(snd_info_get_line); 717 718/** 719 * snd_info_get_str - parse a string token 720 * @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 * 727 * Return: The updated pointer of the original string so that 728 * it can be used for the next call. 729 */ 730const char *snd_info_get_str(char *dest, const char *src, int len) 731{ 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 754EXPORT_SYMBOL(snd_info_get_str); 755 756/** 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 * 766 * Return: The pointer of the new instance, or %NULL on failure. 767 */ 768static struct snd_info_entry *snd_info_create_entry(const char *name) 769{ 770 struct snd_info_entry *entry; 771 entry = kzalloc(sizeof(*entry), GFP_KERNEL); 772 if (entry == NULL) 773 return NULL; 774 entry->name = kstrdup(name, GFP_KERNEL); 775 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; 781 mutex_init(&entry->access); 782 INIT_LIST_HEAD(&entry->children); 783 INIT_LIST_HEAD(&entry->list); 784 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 * 795 * Return: The pointer of the new instance, or %NULL on failure. 796 */ 797struct snd_info_entry *snd_info_create_module_entry(struct module * module, 798 const char *name, 799 struct snd_info_entry *parent) 800{ 801 struct snd_info_entry *entry = snd_info_create_entry(name); 802 if (entry) { 803 entry->module = module; 804 entry->parent = parent; 805 } 806 return entry; 807} 808 809EXPORT_SYMBOL(snd_info_create_module_entry); 810 811/** 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 * 819 * Return: The pointer of the new instance, or %NULL on failure. 820 */ 821struct snd_info_entry *snd_info_create_card_entry(struct snd_card *card, 822 const char *name, 823 struct snd_info_entry * parent) 824{ 825 struct snd_info_entry *entry = snd_info_create_entry(name); 826 if (entry) { 827 entry->module = card->module; 828 entry->card = card; 829 entry->parent = parent; 830 } 831 return entry; 832} 833 834EXPORT_SYMBOL(snd_info_create_card_entry); 835 836static 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; 849 snd_BUG_ON(!root); 850 proc_remove(entry->p); 851 entry->p = NULL; 852} 853 854static int snd_info_dev_free_entry(struct snd_device *device) 855{ 856 struct snd_info_entry *entry = device->device_data; 857 snd_info_free_entry(entry); 858 return 0; 859} 860 861static int snd_info_dev_register_entry(struct snd_device *device) 862{ 863 struct snd_info_entry *entry = device->device_data; 864 return snd_info_register(entry); 865} 866 867/** 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 * 885 * Return: Zero if successful, or a negative error code on failure. 886 */ 887int snd_card_proc_new(struct snd_card *card, const char *name, 888 struct snd_info_entry **entryp) 889{ 890 static struct snd_device_ops ops = { 891 .dev_free = snd_info_dev_free_entry, 892 .dev_register = snd_info_dev_register_entry, 893 /* disconnect is done via snd_info_card_disconnect() */ 894 }; 895 struct snd_info_entry *entry; 896 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 910EXPORT_SYMBOL(snd_card_proc_new); 911 912/** 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 */ 918void snd_info_free_entry(struct snd_info_entry * entry) 919{ 920 if (entry == NULL) 921 return; 922 if (entry->p) { 923 mutex_lock(&info_mutex); 924 snd_info_disconnect(entry); 925 mutex_unlock(&info_mutex); 926 } 927 kfree(entry->name); 928 if (entry->private_free) 929 entry->private_free(entry); 930 kfree(entry); 931} 932 933EXPORT_SYMBOL(snd_info_free_entry); 934 935/** 936 * snd_info_register - register the info entry 937 * @entry: the info entry 938 * 939 * Registers the proc info entry. 940 * 941 * Return: Zero if successful, or a negative error code on failure. 942 */ 943int snd_info_register(struct snd_info_entry * entry) 944{ 945 struct proc_dir_entry *root, *p = NULL; 946 947 if (snd_BUG_ON(!entry)) 948 return -ENXIO; 949 root = entry->parent == NULL ? snd_proc_root : entry->parent->p; 950 mutex_lock(&info_mutex); 951 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 } 964 proc_set_size(p, entry->size); 965 } 966 entry->p = p; 967 if (entry->parent) 968 list_add_tail(&entry->list, &entry->parent->children); 969 mutex_unlock(&info_mutex); 970 return 0; 971} 972 973EXPORT_SYMBOL(snd_info_register); 974 975/* 976 977 */ 978 979static struct snd_info_entry *snd_info_version_entry; 980 981static void snd_info_version_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer) 982{ 983 snd_iprintf(buffer, 984 "Advanced Linux Sound Architecture Driver Version k%s.\n", 985 init_utsname()->release); 986} 987 988static int __init snd_info_version_init(void) 989{ 990 struct snd_info_entry *entry; 991 992 entry = snd_info_create_module_entry(THIS_MODULE, "version", NULL); 993 if (entry == NULL) 994 return -ENOMEM; 995 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{ 1006 snd_info_free_entry(snd_info_version_entry); 1007 return 0; 1008} 1009 1010#endif /* CONFIG_PROC_FS */ 1011