linux/sound/core/init.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0-or-later
   2/*
   3 *  Initialization routines
   4 *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
   5 */
   6
   7#include <linux/init.h>
   8#include <linux/sched.h>
   9#include <linux/module.h>
  10#include <linux/device.h>
  11#include <linux/file.h>
  12#include <linux/slab.h>
  13#include <linux/time.h>
  14#include <linux/ctype.h>
  15#include <linux/pm.h>
  16#include <linux/debugfs.h>
  17#include <linux/completion.h>
  18#include <linux/interrupt.h>
  19
  20#include <sound/core.h>
  21#include <sound/control.h>
  22#include <sound/info.h>
  23
  24/* monitor files for graceful shutdown (hotplug) */
  25struct snd_monitor_file {
  26        struct file *file;
  27        const struct file_operations *disconnected_f_op;
  28        struct list_head shutdown_list; /* still need to shutdown */
  29        struct list_head list;  /* link of monitor files */
  30};
  31
  32static DEFINE_SPINLOCK(shutdown_lock);
  33static LIST_HEAD(shutdown_files);
  34
  35static const struct file_operations snd_shutdown_f_ops;
  36
  37/* locked for registering/using */
  38static DECLARE_BITMAP(snd_cards_lock, SNDRV_CARDS);
  39static struct snd_card *snd_cards[SNDRV_CARDS];
  40
  41static DEFINE_MUTEX(snd_card_mutex);
  42
  43static char *slots[SNDRV_CARDS];
  44module_param_array(slots, charp, NULL, 0444);
  45MODULE_PARM_DESC(slots, "Module names assigned to the slots.");
  46
  47/* return non-zero if the given index is reserved for the given
  48 * module via slots option
  49 */
  50static int module_slot_match(struct module *module, int idx)
  51{
  52        int match = 1;
  53#ifdef MODULE
  54        const char *s1, *s2;
  55
  56        if (!module || !*module->name || !slots[idx])
  57                return 0;
  58
  59        s1 = module->name;
  60        s2 = slots[idx];
  61        if (*s2 == '!') {
  62                match = 0; /* negative match */
  63                s2++;
  64        }
  65        /* compare module name strings
  66         * hyphens are handled as equivalent with underscore
  67         */
  68        for (;;) {
  69                char c1 = *s1++;
  70                char c2 = *s2++;
  71                if (c1 == '-')
  72                        c1 = '_';
  73                if (c2 == '-')
  74                        c2 = '_';
  75                if (c1 != c2)
  76                        return !match;
  77                if (!c1)
  78                        break;
  79        }
  80#endif /* MODULE */
  81        return match;
  82}
  83
  84#if IS_ENABLED(CONFIG_SND_MIXER_OSS)
  85int (*snd_mixer_oss_notify_callback)(struct snd_card *card, int free_flag);
  86EXPORT_SYMBOL(snd_mixer_oss_notify_callback);
  87#endif
  88
  89static int check_empty_slot(struct module *module, int slot)
  90{
  91        return !slots[slot] || !*slots[slot];
  92}
  93
  94/* return an empty slot number (>= 0) found in the given bitmask @mask.
  95 * @mask == -1 == 0xffffffff means: take any free slot up to 32
  96 * when no slot is available, return the original @mask as is.
  97 */
  98static int get_slot_from_bitmask(int mask, int (*check)(struct module *, int),
  99                                 struct module *module)
 100{
 101        int slot;
 102
 103        for (slot = 0; slot < SNDRV_CARDS; slot++) {
 104                if (slot < 32 && !(mask & (1U << slot)))
 105                        continue;
 106                if (!test_bit(slot, snd_cards_lock)) {
 107                        if (check(module, slot))
 108                                return slot; /* found */
 109                }
 110        }
 111        return mask; /* unchanged */
 112}
 113
 114/* the default release callback set in snd_device_initialize() below;
 115 * this is just NOP for now, as almost all jobs are already done in
 116 * dev_free callback of snd_device chain instead.
 117 */
 118static void default_release(struct device *dev)
 119{
 120}
 121
 122/**
 123 * snd_device_initialize - Initialize struct device for sound devices
 124 * @dev: device to initialize
 125 * @card: card to assign, optional
 126 */
 127void snd_device_initialize(struct device *dev, struct snd_card *card)
 128{
 129        device_initialize(dev);
 130        if (card)
 131                dev->parent = &card->card_dev;
 132        dev->class = sound_class;
 133        dev->release = default_release;
 134}
 135EXPORT_SYMBOL_GPL(snd_device_initialize);
 136
 137static int snd_card_do_free(struct snd_card *card);
 138static const struct attribute_group card_dev_attr_group;
 139
 140static void release_card_device(struct device *dev)
 141{
 142        snd_card_do_free(dev_to_snd_card(dev));
 143}
 144
 145/**
 146 *  snd_card_new - create and initialize a soundcard structure
 147 *  @parent: the parent device object
 148 *  @idx: card index (address) [0 ... (SNDRV_CARDS-1)]
 149 *  @xid: card identification (ASCII string)
 150 *  @module: top level module for locking
 151 *  @extra_size: allocate this extra size after the main soundcard structure
 152 *  @card_ret: the pointer to store the created card instance
 153 *
 154 *  The function allocates snd_card instance via kzalloc with the given
 155 *  space for the driver to use freely.  The allocated struct is stored
 156 *  in the given card_ret pointer.
 157 *
 158 *  Return: Zero if successful or a negative error code.
 159 */
 160int snd_card_new(struct device *parent, int idx, const char *xid,
 161                    struct module *module, int extra_size,
 162                    struct snd_card **card_ret)
 163{
 164        struct snd_card *card;
 165        int err;
 166#ifdef CONFIG_SND_DEBUG
 167        char name[8];
 168#endif
 169
 170        if (snd_BUG_ON(!card_ret))
 171                return -EINVAL;
 172        *card_ret = NULL;
 173
 174        if (extra_size < 0)
 175                extra_size = 0;
 176        card = kzalloc(sizeof(*card) + extra_size, GFP_KERNEL);
 177        if (!card)
 178                return -ENOMEM;
 179        if (extra_size > 0)
 180                card->private_data = (char *)card + sizeof(struct snd_card);
 181        if (xid)
 182                strscpy(card->id, xid, sizeof(card->id));
 183        err = 0;
 184        mutex_lock(&snd_card_mutex);
 185        if (idx < 0) /* first check the matching module-name slot */
 186                idx = get_slot_from_bitmask(idx, module_slot_match, module);
 187        if (idx < 0) /* if not matched, assign an empty slot */
 188                idx = get_slot_from_bitmask(idx, check_empty_slot, module);
 189        if (idx < 0)
 190                err = -ENODEV;
 191        else if (idx < snd_ecards_limit) {
 192                if (test_bit(idx, snd_cards_lock))
 193                        err = -EBUSY;   /* invalid */
 194        } else if (idx >= SNDRV_CARDS)
 195                err = -ENODEV;
 196        if (err < 0) {
 197                mutex_unlock(&snd_card_mutex);
 198                dev_err(parent, "cannot find the slot for index %d (range 0-%i), error: %d\n",
 199                         idx, snd_ecards_limit - 1, err);
 200                kfree(card);
 201                return err;
 202        }
 203        set_bit(idx, snd_cards_lock);           /* lock it */
 204        if (idx >= snd_ecards_limit)
 205                snd_ecards_limit = idx + 1; /* increase the limit */
 206        mutex_unlock(&snd_card_mutex);
 207        card->dev = parent;
 208        card->number = idx;
 209#ifdef MODULE
 210        WARN_ON(!module);
 211        card->module = module;
 212#endif
 213        INIT_LIST_HEAD(&card->devices);
 214        init_rwsem(&card->controls_rwsem);
 215        rwlock_init(&card->ctl_files_rwlock);
 216        INIT_LIST_HEAD(&card->controls);
 217        INIT_LIST_HEAD(&card->ctl_files);
 218        spin_lock_init(&card->files_lock);
 219        INIT_LIST_HEAD(&card->files_list);
 220        mutex_init(&card->memory_mutex);
 221#ifdef CONFIG_PM
 222        init_waitqueue_head(&card->power_sleep);
 223        init_waitqueue_head(&card->power_ref_sleep);
 224        atomic_set(&card->power_ref, 0);
 225#endif
 226        init_waitqueue_head(&card->remove_sleep);
 227        card->sync_irq = -1;
 228
 229        device_initialize(&card->card_dev);
 230        card->card_dev.parent = parent;
 231        card->card_dev.class = sound_class;
 232        card->card_dev.release = release_card_device;
 233        card->card_dev.groups = card->dev_groups;
 234        card->dev_groups[0] = &card_dev_attr_group;
 235        err = kobject_set_name(&card->card_dev.kobj, "card%d", idx);
 236        if (err < 0)
 237                goto __error;
 238
 239        snprintf(card->irq_descr, sizeof(card->irq_descr), "%s:%s",
 240                 dev_driver_string(card->dev), dev_name(&card->card_dev));
 241
 242        /* the control interface cannot be accessed from the user space until */
 243        /* snd_cards_bitmask and snd_cards are set with snd_card_register */
 244        err = snd_ctl_create(card);
 245        if (err < 0) {
 246                dev_err(parent, "unable to register control minors\n");
 247                goto __error;
 248        }
 249        err = snd_info_card_create(card);
 250        if (err < 0) {
 251                dev_err(parent, "unable to create card info\n");
 252                goto __error_ctl;
 253        }
 254
 255#ifdef CONFIG_SND_DEBUG
 256        sprintf(name, "card%d", idx);
 257        card->debugfs_root = debugfs_create_dir(name, sound_debugfs_root);
 258#endif
 259
 260        *card_ret = card;
 261        return 0;
 262
 263      __error_ctl:
 264        snd_device_free_all(card);
 265      __error:
 266        put_device(&card->card_dev);
 267        return err;
 268}
 269EXPORT_SYMBOL(snd_card_new);
 270
 271/**
 272 * snd_card_ref - Get the card object from the index
 273 * @idx: the card index
 274 *
 275 * Returns a card object corresponding to the given index or NULL if not found.
 276 * Release the object via snd_card_unref().
 277 */
 278struct snd_card *snd_card_ref(int idx)
 279{
 280        struct snd_card *card;
 281
 282        mutex_lock(&snd_card_mutex);
 283        card = snd_cards[idx];
 284        if (card)
 285                get_device(&card->card_dev);
 286        mutex_unlock(&snd_card_mutex);
 287        return card;
 288}
 289EXPORT_SYMBOL_GPL(snd_card_ref);
 290
 291/* return non-zero if a card is already locked */
 292int snd_card_locked(int card)
 293{
 294        int locked;
 295
 296        mutex_lock(&snd_card_mutex);
 297        locked = test_bit(card, snd_cards_lock);
 298        mutex_unlock(&snd_card_mutex);
 299        return locked;
 300}
 301
 302static loff_t snd_disconnect_llseek(struct file *file, loff_t offset, int orig)
 303{
 304        return -ENODEV;
 305}
 306
 307static ssize_t snd_disconnect_read(struct file *file, char __user *buf,
 308                                   size_t count, loff_t *offset)
 309{
 310        return -ENODEV;
 311}
 312
 313static ssize_t snd_disconnect_write(struct file *file, const char __user *buf,
 314                                    size_t count, loff_t *offset)
 315{
 316        return -ENODEV;
 317}
 318
 319static int snd_disconnect_release(struct inode *inode, struct file *file)
 320{
 321        struct snd_monitor_file *df = NULL, *_df;
 322
 323        spin_lock(&shutdown_lock);
 324        list_for_each_entry(_df, &shutdown_files, shutdown_list) {
 325                if (_df->file == file) {
 326                        df = _df;
 327                        list_del_init(&df->shutdown_list);
 328                        break;
 329                }
 330        }
 331        spin_unlock(&shutdown_lock);
 332
 333        if (likely(df)) {
 334                if ((file->f_flags & FASYNC) && df->disconnected_f_op->fasync)
 335                        df->disconnected_f_op->fasync(-1, file, 0);
 336                return df->disconnected_f_op->release(inode, file);
 337        }
 338
 339        panic("%s(%p, %p) failed!", __func__, inode, file);
 340}
 341
 342static __poll_t snd_disconnect_poll(struct file * file, poll_table * wait)
 343{
 344        return EPOLLERR | EPOLLNVAL;
 345}
 346
 347static long snd_disconnect_ioctl(struct file *file,
 348                                 unsigned int cmd, unsigned long arg)
 349{
 350        return -ENODEV;
 351}
 352
 353static int snd_disconnect_mmap(struct file *file, struct vm_area_struct *vma)
 354{
 355        return -ENODEV;
 356}
 357
 358static int snd_disconnect_fasync(int fd, struct file *file, int on)
 359{
 360        return -ENODEV;
 361}
 362
 363static const struct file_operations snd_shutdown_f_ops =
 364{
 365        .owner =        THIS_MODULE,
 366        .llseek =       snd_disconnect_llseek,
 367        .read =         snd_disconnect_read,
 368        .write =        snd_disconnect_write,
 369        .release =      snd_disconnect_release,
 370        .poll =         snd_disconnect_poll,
 371        .unlocked_ioctl = snd_disconnect_ioctl,
 372#ifdef CONFIG_COMPAT
 373        .compat_ioctl = snd_disconnect_ioctl,
 374#endif
 375        .mmap =         snd_disconnect_mmap,
 376        .fasync =       snd_disconnect_fasync
 377};
 378
 379/**
 380 *  snd_card_disconnect - disconnect all APIs from the file-operations (user space)
 381 *  @card: soundcard structure
 382 *
 383 *  Disconnects all APIs from the file-operations (user space).
 384 *
 385 *  Return: Zero, otherwise a negative error code.
 386 *
 387 *  Note: The current implementation replaces all active file->f_op with special
 388 *        dummy file operations (they do nothing except release).
 389 */
 390int snd_card_disconnect(struct snd_card *card)
 391{
 392        struct snd_monitor_file *mfile;
 393
 394        if (!card)
 395                return -EINVAL;
 396
 397        spin_lock(&card->files_lock);
 398        if (card->shutdown) {
 399                spin_unlock(&card->files_lock);
 400                return 0;
 401        }
 402        card->shutdown = 1;
 403
 404        /* replace file->f_op with special dummy operations */
 405        list_for_each_entry(mfile, &card->files_list, list) {
 406                /* it's critical part, use endless loop */
 407                /* we have no room to fail */
 408                mfile->disconnected_f_op = mfile->file->f_op;
 409
 410                spin_lock(&shutdown_lock);
 411                list_add(&mfile->shutdown_list, &shutdown_files);
 412                spin_unlock(&shutdown_lock);
 413
 414                mfile->file->f_op = &snd_shutdown_f_ops;
 415                fops_get(mfile->file->f_op);
 416        }
 417        spin_unlock(&card->files_lock); 
 418
 419        /* notify all connected devices about disconnection */
 420        /* at this point, they cannot respond to any calls except release() */
 421
 422#if IS_ENABLED(CONFIG_SND_MIXER_OSS)
 423        if (snd_mixer_oss_notify_callback)
 424                snd_mixer_oss_notify_callback(card, SND_MIXER_OSS_NOTIFY_DISCONNECT);
 425#endif
 426
 427        /* notify all devices that we are disconnected */
 428        snd_device_disconnect_all(card);
 429
 430        if (card->sync_irq > 0)
 431                synchronize_irq(card->sync_irq);
 432
 433        snd_info_card_disconnect(card);
 434        if (card->registered) {
 435                device_del(&card->card_dev);
 436                card->registered = false;
 437        }
 438
 439        /* disable fops (user space) operations for ALSA API */
 440        mutex_lock(&snd_card_mutex);
 441        snd_cards[card->number] = NULL;
 442        clear_bit(card->number, snd_cards_lock);
 443        mutex_unlock(&snd_card_mutex);
 444
 445#ifdef CONFIG_PM
 446        wake_up(&card->power_sleep);
 447        snd_power_sync_ref(card);
 448#endif
 449        return 0;       
 450}
 451EXPORT_SYMBOL(snd_card_disconnect);
 452
 453/**
 454 * snd_card_disconnect_sync - disconnect card and wait until files get closed
 455 * @card: card object to disconnect
 456 *
 457 * This calls snd_card_disconnect() for disconnecting all belonging components
 458 * and waits until all pending files get closed.
 459 * It assures that all accesses from user-space finished so that the driver
 460 * can release its resources gracefully.
 461 */
 462void snd_card_disconnect_sync(struct snd_card *card)
 463{
 464        int err;
 465
 466        err = snd_card_disconnect(card);
 467        if (err < 0) {
 468                dev_err(card->dev,
 469                        "snd_card_disconnect error (%d), skipping sync\n",
 470                        err);
 471                return;
 472        }
 473
 474        spin_lock_irq(&card->files_lock);
 475        wait_event_lock_irq(card->remove_sleep,
 476                            list_empty(&card->files_list),
 477                            card->files_lock);
 478        spin_unlock_irq(&card->files_lock);
 479}
 480EXPORT_SYMBOL_GPL(snd_card_disconnect_sync);
 481
 482static int snd_card_do_free(struct snd_card *card)
 483{
 484#if IS_ENABLED(CONFIG_SND_MIXER_OSS)
 485        if (snd_mixer_oss_notify_callback)
 486                snd_mixer_oss_notify_callback(card, SND_MIXER_OSS_NOTIFY_FREE);
 487#endif
 488        snd_device_free_all(card);
 489        if (card->private_free)
 490                card->private_free(card);
 491        if (snd_info_card_free(card) < 0) {
 492                dev_warn(card->dev, "unable to free card info\n");
 493                /* Not fatal error */
 494        }
 495#ifdef CONFIG_SND_DEBUG
 496        debugfs_remove(card->debugfs_root);
 497        card->debugfs_root = NULL;
 498#endif
 499        if (card->release_completion)
 500                complete(card->release_completion);
 501        kfree(card);
 502        return 0;
 503}
 504
 505/**
 506 * snd_card_free_when_closed - Disconnect the card, free it later eventually
 507 * @card: soundcard structure
 508 *
 509 * Unlike snd_card_free(), this function doesn't try to release the card
 510 * resource immediately, but tries to disconnect at first.  When the card
 511 * is still in use, the function returns before freeing the resources.
 512 * The card resources will be freed when the refcount gets to zero.
 513 */
 514int snd_card_free_when_closed(struct snd_card *card)
 515{
 516        int ret = snd_card_disconnect(card);
 517        if (ret)
 518                return ret;
 519        put_device(&card->card_dev);
 520        return 0;
 521}
 522EXPORT_SYMBOL(snd_card_free_when_closed);
 523
 524/**
 525 * snd_card_free - frees given soundcard structure
 526 * @card: soundcard structure
 527 *
 528 * This function releases the soundcard structure and the all assigned
 529 * devices automatically.  That is, you don't have to release the devices
 530 * by yourself.
 531 *
 532 * This function waits until the all resources are properly released.
 533 *
 534 * Return: Zero. Frees all associated devices and frees the control
 535 * interface associated to given soundcard.
 536 */
 537int snd_card_free(struct snd_card *card)
 538{
 539        DECLARE_COMPLETION_ONSTACK(released);
 540        int ret;
 541
 542        card->release_completion = &released;
 543        ret = snd_card_free_when_closed(card);
 544        if (ret)
 545                return ret;
 546        /* wait, until all devices are ready for the free operation */
 547        wait_for_completion(&released);
 548
 549        return 0;
 550}
 551EXPORT_SYMBOL(snd_card_free);
 552
 553/* retrieve the last word of shortname or longname */
 554static const char *retrieve_id_from_card_name(const char *name)
 555{
 556        const char *spos = name;
 557
 558        while (*name) {
 559                if (isspace(*name) && isalnum(name[1]))
 560                        spos = name + 1;
 561                name++;
 562        }
 563        return spos;
 564}
 565
 566/* return true if the given id string doesn't conflict any other card ids */
 567static bool card_id_ok(struct snd_card *card, const char *id)
 568{
 569        int i;
 570        if (!snd_info_check_reserved_words(id))
 571                return false;
 572        for (i = 0; i < snd_ecards_limit; i++) {
 573                if (snd_cards[i] && snd_cards[i] != card &&
 574                    !strcmp(snd_cards[i]->id, id))
 575                        return false;
 576        }
 577        return true;
 578}
 579
 580/* copy to card->id only with valid letters from nid */
 581static void copy_valid_id_string(struct snd_card *card, const char *src,
 582                                 const char *nid)
 583{
 584        char *id = card->id;
 585
 586        while (*nid && !isalnum(*nid))
 587                nid++;
 588        if (isdigit(*nid))
 589                *id++ = isalpha(*src) ? *src : 'D';
 590        while (*nid && (size_t)(id - card->id) < sizeof(card->id) - 1) {
 591                if (isalnum(*nid))
 592                        *id++ = *nid;
 593                nid++;
 594        }
 595        *id = 0;
 596}
 597
 598/* Set card->id from the given string
 599 * If the string conflicts with other ids, add a suffix to make it unique.
 600 */
 601static void snd_card_set_id_no_lock(struct snd_card *card, const char *src,
 602                                    const char *nid)
 603{
 604        int len, loops;
 605        bool is_default = false;
 606        char *id;
 607        
 608        copy_valid_id_string(card, src, nid);
 609        id = card->id;
 610
 611 again:
 612        /* use "Default" for obviously invalid strings
 613         * ("card" conflicts with proc directories)
 614         */
 615        if (!*id || !strncmp(id, "card", 4)) {
 616                strcpy(id, "Default");
 617                is_default = true;
 618        }
 619
 620        len = strlen(id);
 621        for (loops = 0; loops < SNDRV_CARDS; loops++) {
 622                char *spos;
 623                char sfxstr[5]; /* "_012" */
 624                int sfxlen;
 625
 626                if (card_id_ok(card, id))
 627                        return; /* OK */
 628
 629                /* Add _XYZ suffix */
 630                sprintf(sfxstr, "_%X", loops + 1);
 631                sfxlen = strlen(sfxstr);
 632                if (len + sfxlen >= sizeof(card->id))
 633                        spos = id + sizeof(card->id) - sfxlen - 1;
 634                else
 635                        spos = id + len;
 636                strcpy(spos, sfxstr);
 637        }
 638        /* fallback to the default id */
 639        if (!is_default) {
 640                *id = 0;
 641                goto again;
 642        }
 643        /* last resort... */
 644        dev_err(card->dev, "unable to set card id (%s)\n", id);
 645        if (card->proc_root->name)
 646                strscpy(card->id, card->proc_root->name, sizeof(card->id));
 647}
 648
 649/**
 650 *  snd_card_set_id - set card identification name
 651 *  @card: soundcard structure
 652 *  @nid: new identification string
 653 *
 654 *  This function sets the card identification and checks for name
 655 *  collisions.
 656 */
 657void snd_card_set_id(struct snd_card *card, const char *nid)
 658{
 659        /* check if user specified own card->id */
 660        if (card->id[0] != '\0')
 661                return;
 662        mutex_lock(&snd_card_mutex);
 663        snd_card_set_id_no_lock(card, nid, nid);
 664        mutex_unlock(&snd_card_mutex);
 665}
 666EXPORT_SYMBOL(snd_card_set_id);
 667
 668static ssize_t id_show(struct device *dev,
 669                       struct device_attribute *attr, char *buf)
 670{
 671        struct snd_card *card = container_of(dev, struct snd_card, card_dev);
 672        return scnprintf(buf, PAGE_SIZE, "%s\n", card->id);
 673}
 674
 675static ssize_t id_store(struct device *dev, struct device_attribute *attr,
 676                        const char *buf, size_t count)
 677{
 678        struct snd_card *card = container_of(dev, struct snd_card, card_dev);
 679        char buf1[sizeof(card->id)];
 680        size_t copy = count > sizeof(card->id) - 1 ?
 681                                        sizeof(card->id) - 1 : count;
 682        size_t idx;
 683        int c;
 684
 685        for (idx = 0; idx < copy; idx++) {
 686                c = buf[idx];
 687                if (!isalnum(c) && c != '_' && c != '-')
 688                        return -EINVAL;
 689        }
 690        memcpy(buf1, buf, copy);
 691        buf1[copy] = '\0';
 692        mutex_lock(&snd_card_mutex);
 693        if (!card_id_ok(NULL, buf1)) {
 694                mutex_unlock(&snd_card_mutex);
 695                return -EEXIST;
 696        }
 697        strcpy(card->id, buf1);
 698        snd_info_card_id_change(card);
 699        mutex_unlock(&snd_card_mutex);
 700
 701        return count;
 702}
 703
 704static DEVICE_ATTR_RW(id);
 705
 706static ssize_t number_show(struct device *dev,
 707                           struct device_attribute *attr, char *buf)
 708{
 709        struct snd_card *card = container_of(dev, struct snd_card, card_dev);
 710        return scnprintf(buf, PAGE_SIZE, "%i\n", card->number);
 711}
 712
 713static DEVICE_ATTR_RO(number);
 714
 715static struct attribute *card_dev_attrs[] = {
 716        &dev_attr_id.attr,
 717        &dev_attr_number.attr,
 718        NULL
 719};
 720
 721static const struct attribute_group card_dev_attr_group = {
 722        .attrs  = card_dev_attrs,
 723};
 724
 725/**
 726 * snd_card_add_dev_attr - Append a new sysfs attribute group to card
 727 * @card: card instance
 728 * @group: attribute group to append
 729 */
 730int snd_card_add_dev_attr(struct snd_card *card,
 731                          const struct attribute_group *group)
 732{
 733        int i;
 734
 735        /* loop for (arraysize-1) here to keep NULL at the last entry */
 736        for (i = 0; i < ARRAY_SIZE(card->dev_groups) - 1; i++) {
 737                if (!card->dev_groups[i]) {
 738                        card->dev_groups[i] = group;
 739                        return 0;
 740                }
 741        }
 742
 743        dev_err(card->dev, "Too many groups assigned\n");
 744        return -ENOSPC;
 745}
 746EXPORT_SYMBOL_GPL(snd_card_add_dev_attr);
 747
 748/**
 749 *  snd_card_register - register the soundcard
 750 *  @card: soundcard structure
 751 *
 752 *  This function registers all the devices assigned to the soundcard.
 753 *  Until calling this, the ALSA control interface is blocked from the
 754 *  external accesses.  Thus, you should call this function at the end
 755 *  of the initialization of the card.
 756 *
 757 *  Return: Zero otherwise a negative error code if the registration failed.
 758 */
 759int snd_card_register(struct snd_card *card)
 760{
 761        int err;
 762
 763        if (snd_BUG_ON(!card))
 764                return -EINVAL;
 765
 766        if (!card->registered) {
 767                err = device_add(&card->card_dev);
 768                if (err < 0)
 769                        return err;
 770                card->registered = true;
 771        }
 772
 773        err = snd_device_register_all(card);
 774        if (err < 0)
 775                return err;
 776        mutex_lock(&snd_card_mutex);
 777        if (snd_cards[card->number]) {
 778                /* already registered */
 779                mutex_unlock(&snd_card_mutex);
 780                return snd_info_card_register(card); /* register pending info */
 781        }
 782        if (*card->id) {
 783                /* make a unique id name from the given string */
 784                char tmpid[sizeof(card->id)];
 785                memcpy(tmpid, card->id, sizeof(card->id));
 786                snd_card_set_id_no_lock(card, tmpid, tmpid);
 787        } else {
 788                /* create an id from either shortname or longname */
 789                const char *src;
 790                src = *card->shortname ? card->shortname : card->longname;
 791                snd_card_set_id_no_lock(card, src,
 792                                        retrieve_id_from_card_name(src));
 793        }
 794        snd_cards[card->number] = card;
 795        mutex_unlock(&snd_card_mutex);
 796        err = snd_info_card_register(card);
 797        if (err < 0)
 798                return err;
 799
 800#if IS_ENABLED(CONFIG_SND_MIXER_OSS)
 801        if (snd_mixer_oss_notify_callback)
 802                snd_mixer_oss_notify_callback(card, SND_MIXER_OSS_NOTIFY_REGISTER);
 803#endif
 804        return 0;
 805}
 806EXPORT_SYMBOL(snd_card_register);
 807
 808#ifdef CONFIG_SND_PROC_FS
 809static void snd_card_info_read(struct snd_info_entry *entry,
 810                               struct snd_info_buffer *buffer)
 811{
 812        int idx, count;
 813        struct snd_card *card;
 814
 815        for (idx = count = 0; idx < SNDRV_CARDS; idx++) {
 816                mutex_lock(&snd_card_mutex);
 817                card = snd_cards[idx];
 818                if (card) {
 819                        count++;
 820                        snd_iprintf(buffer, "%2i [%-15s]: %s - %s\n",
 821                                        idx,
 822                                        card->id,
 823                                        card->driver,
 824                                        card->shortname);
 825                        snd_iprintf(buffer, "                      %s\n",
 826                                        card->longname);
 827                }
 828                mutex_unlock(&snd_card_mutex);
 829        }
 830        if (!count)
 831                snd_iprintf(buffer, "--- no soundcards ---\n");
 832}
 833
 834#ifdef CONFIG_SND_OSSEMUL
 835void snd_card_info_read_oss(struct snd_info_buffer *buffer)
 836{
 837        int idx, count;
 838        struct snd_card *card;
 839
 840        for (idx = count = 0; idx < SNDRV_CARDS; idx++) {
 841                mutex_lock(&snd_card_mutex);
 842                card = snd_cards[idx];
 843                if (card) {
 844                        count++;
 845                        snd_iprintf(buffer, "%s\n", card->longname);
 846                }
 847                mutex_unlock(&snd_card_mutex);
 848        }
 849        if (!count) {
 850                snd_iprintf(buffer, "--- no soundcards ---\n");
 851        }
 852}
 853
 854#endif
 855
 856#ifdef MODULE
 857static void snd_card_module_info_read(struct snd_info_entry *entry,
 858                                      struct snd_info_buffer *buffer)
 859{
 860        int idx;
 861        struct snd_card *card;
 862
 863        for (idx = 0; idx < SNDRV_CARDS; idx++) {
 864                mutex_lock(&snd_card_mutex);
 865                card = snd_cards[idx];
 866                if (card)
 867                        snd_iprintf(buffer, "%2i %s\n",
 868                                    idx, card->module->name);
 869                mutex_unlock(&snd_card_mutex);
 870        }
 871}
 872#endif
 873
 874int __init snd_card_info_init(void)
 875{
 876        struct snd_info_entry *entry;
 877
 878        entry = snd_info_create_module_entry(THIS_MODULE, "cards", NULL);
 879        if (! entry)
 880                return -ENOMEM;
 881        entry->c.text.read = snd_card_info_read;
 882        if (snd_info_register(entry) < 0)
 883                return -ENOMEM; /* freed in error path */
 884
 885#ifdef MODULE
 886        entry = snd_info_create_module_entry(THIS_MODULE, "modules", NULL);
 887        if (!entry)
 888                return -ENOMEM;
 889        entry->c.text.read = snd_card_module_info_read;
 890        if (snd_info_register(entry) < 0)
 891                return -ENOMEM; /* freed in error path */
 892#endif
 893
 894        return 0;
 895}
 896#endif /* CONFIG_SND_PROC_FS */
 897
 898/**
 899 *  snd_component_add - add a component string
 900 *  @card: soundcard structure
 901 *  @component: the component id string
 902 *
 903 *  This function adds the component id string to the supported list.
 904 *  The component can be referred from the alsa-lib.
 905 *
 906 *  Return: Zero otherwise a negative error code.
 907 */
 908  
 909int snd_component_add(struct snd_card *card, const char *component)
 910{
 911        char *ptr;
 912        int len = strlen(component);
 913
 914        ptr = strstr(card->components, component);
 915        if (ptr != NULL) {
 916                if (ptr[len] == '\0' || ptr[len] == ' ')        /* already there */
 917                        return 1;
 918        }
 919        if (strlen(card->components) + 1 + len + 1 > sizeof(card->components)) {
 920                snd_BUG();
 921                return -ENOMEM;
 922        }
 923        if (card->components[0] != '\0')
 924                strcat(card->components, " ");
 925        strcat(card->components, component);
 926        return 0;
 927}
 928EXPORT_SYMBOL(snd_component_add);
 929
 930/**
 931 *  snd_card_file_add - add the file to the file list of the card
 932 *  @card: soundcard structure
 933 *  @file: file pointer
 934 *
 935 *  This function adds the file to the file linked-list of the card.
 936 *  This linked-list is used to keep tracking the connection state,
 937 *  and to avoid the release of busy resources by hotplug.
 938 *
 939 *  Return: zero or a negative error code.
 940 */
 941int snd_card_file_add(struct snd_card *card, struct file *file)
 942{
 943        struct snd_monitor_file *mfile;
 944
 945        mfile = kmalloc(sizeof(*mfile), GFP_KERNEL);
 946        if (mfile == NULL)
 947                return -ENOMEM;
 948        mfile->file = file;
 949        mfile->disconnected_f_op = NULL;
 950        INIT_LIST_HEAD(&mfile->shutdown_list);
 951        spin_lock(&card->files_lock);
 952        if (card->shutdown) {
 953                spin_unlock(&card->files_lock);
 954                kfree(mfile);
 955                return -ENODEV;
 956        }
 957        list_add(&mfile->list, &card->files_list);
 958        get_device(&card->card_dev);
 959        spin_unlock(&card->files_lock);
 960        return 0;
 961}
 962EXPORT_SYMBOL(snd_card_file_add);
 963
 964/**
 965 *  snd_card_file_remove - remove the file from the file list
 966 *  @card: soundcard structure
 967 *  @file: file pointer
 968 *
 969 *  This function removes the file formerly added to the card via
 970 *  snd_card_file_add() function.
 971 *  If all files are removed and snd_card_free_when_closed() was
 972 *  called beforehand, it processes the pending release of
 973 *  resources.
 974 *
 975 *  Return: Zero or a negative error code.
 976 */
 977int snd_card_file_remove(struct snd_card *card, struct file *file)
 978{
 979        struct snd_monitor_file *mfile, *found = NULL;
 980
 981        spin_lock(&card->files_lock);
 982        list_for_each_entry(mfile, &card->files_list, list) {
 983                if (mfile->file == file) {
 984                        list_del(&mfile->list);
 985                        spin_lock(&shutdown_lock);
 986                        list_del(&mfile->shutdown_list);
 987                        spin_unlock(&shutdown_lock);
 988                        if (mfile->disconnected_f_op)
 989                                fops_put(mfile->disconnected_f_op);
 990                        found = mfile;
 991                        break;
 992                }
 993        }
 994        if (list_empty(&card->files_list))
 995                wake_up_all(&card->remove_sleep);
 996        spin_unlock(&card->files_lock);
 997        if (!found) {
 998                dev_err(card->dev, "card file remove problem (%p)\n", file);
 999                return -ENOENT;
1000        }
1001        kfree(found);
1002        put_device(&card->card_dev);
1003        return 0;
1004}
1005EXPORT_SYMBOL(snd_card_file_remove);
1006
1007#ifdef CONFIG_PM
1008/**
1009 * snd_power_ref_and_wait - wait until the card gets powered up
1010 * @card: soundcard structure
1011 *
1012 * Take the power_ref reference count of the given card, and
1013 * wait until the card gets powered up to SNDRV_CTL_POWER_D0 state.
1014 * The refcount is down again while sleeping until power-up, hence this
1015 * function can be used for syncing the floating control ops accesses,
1016 * typically around calling control ops.
1017 *
1018 * The caller needs to pull down the refcount via snd_power_unref() later
1019 * no matter whether the error is returned from this function or not.
1020 *
1021 * Return: Zero if successful, or a negative error code.
1022 */
1023int snd_power_ref_and_wait(struct snd_card *card)
1024{
1025        wait_queue_entry_t wait;
1026        int result = 0;
1027
1028        snd_power_ref(card);
1029        /* fastpath */
1030        if (snd_power_get_state(card) == SNDRV_CTL_POWER_D0)
1031                return 0;
1032        init_waitqueue_entry(&wait, current);
1033        add_wait_queue(&card->power_sleep, &wait);
1034        while (1) {
1035                if (card->shutdown) {
1036                        result = -ENODEV;
1037                        break;
1038                }
1039                if (snd_power_get_state(card) == SNDRV_CTL_POWER_D0)
1040                        break;
1041                snd_power_unref(card);
1042                set_current_state(TASK_UNINTERRUPTIBLE);
1043                schedule_timeout(30 * HZ);
1044                snd_power_ref(card);
1045        }
1046        remove_wait_queue(&card->power_sleep, &wait);
1047        return result;
1048}
1049EXPORT_SYMBOL_GPL(snd_power_ref_and_wait);
1050
1051/**
1052 * snd_power_wait - wait until the card gets powered up (old form)
1053 * @card: soundcard structure
1054 *
1055 * Wait until the card gets powered up to SNDRV_CTL_POWER_D0 state.
1056 *
1057 * Return: Zero if successful, or a negative error code.
1058 */
1059int snd_power_wait(struct snd_card *card)
1060{
1061        int ret;
1062
1063        ret = snd_power_ref_and_wait(card);
1064        snd_power_unref(card);
1065        return ret;
1066}
1067EXPORT_SYMBOL(snd_power_wait);
1068#endif /* CONFIG_PM */
1069
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.