sound/core/init.c

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