| 1 | |
| 2 | |
| 3 | * Initialization routines
|
| 4 | * Copyright (c) by Jaroslav Kysela <[email protected]>
|
| 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 |
|
| 25 | struct snd_monitor_file {
|
| 26 | struct file *file;
|
| 27 | const struct file_operations *disconnected_f_op;
|
| 28 | struct list_head shutdown_list;
|
| 29 | struct list_head list;
|
| 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 |
|
| 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 | |
| 48 | * module via slots option
|
| 49 |
|
| 50 | static int module_slot_match(struct module *module, int idx)
|
| 51 | {
|
| 52 | int match = 1;
|
| 53 | #ifdef CONFIG_MODULES
|
| 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;
|
| 63 | s2++;
|
| 64 | }
|
| 65 | |
| 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
|
| 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 | |
| 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;
|
| 109 | }
|
| 110 | }
|
| 111 | return mask;
|
| 112 | }
|
| 113 |
|
| 114 |
|
| 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_obj(*dev);
|
| 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_flex(*card, private_data_area, extra_size);
|
| 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;
|
| 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,
|
| 236 | struct_size(card, private_data_area, extra_size),
|
| 237 | GFP_KERNEL);
|
| 238 | if (!card)
|
| 239 | return -ENOMEM;
|
| 240 | card->managed = true;
|
| 241 | err = snd_card_init(card, parent, idx, xid, module, extra_size);
|
| 242 | if (err < 0) {
|
| 243 | devres_free(card);
|
| 244 | return err;
|
| 245 | }
|
| 246 |
|
| 247 | devres_add(parent, card);
|
| 248 | *card_ret = card;
|
| 249 | return 0;
|
| 250 | }
|
| 251 | EXPORT_SYMBOL_GPL(snd_devm_card_new);
|
| 252 |
|
| 253 | |
| 254 | * snd_card_free_on_error - a small helper for handling devm probe errors
|
| 255 | * @dev: the managed device object
|
| 256 | * @ret: the return code from the probe callback
|
| 257 | *
|
| 258 | * This function handles the explicit snd_card_free() call at the error from
|
| 259 | * the probe callback. It's just a small helper for simplifying the error
|
| 260 | * handling with the managed devices.
|
| 261 | *
|
| 262 | * Return: zero if successful, or a negative error code
|
| 263 |
|
| 264 | int snd_card_free_on_error(struct device *dev, int ret)
|
| 265 | {
|
| 266 | struct snd_card *card;
|
| 267 |
|
| 268 | if (!ret)
|
| 269 | return 0;
|
| 270 | card = devres_find(dev, __snd_card_release, NULL, NULL);
|
| 271 | if (card)
|
| 272 | snd_card_free(card);
|
| 273 | return ret;
|
| 274 | }
|
| 275 | EXPORT_SYMBOL_GPL(snd_card_free_on_error);
|
| 276 |
|
| 277 | static int snd_card_init(struct snd_card *card, struct device *parent,
|
| 278 | int idx, const char *xid, struct module *module,
|
| 279 | size_t extra_size)
|
| 280 | {
|
| 281 | int err;
|
| 282 |
|
| 283 | if (extra_size > 0)
|
| 284 | card->private_data = card->private_data_area;
|
| 285 | if (xid)
|
| 286 | strscpy(card->id, xid, sizeof(card->id));
|
| 287 | err = 0;
|
| 288 | scoped_guard(mutex, &snd_card_mutex) {
|
| 289 | if (idx < 0)
|
| 290 | idx = get_slot_from_bitmask(idx, module_slot_match, module);
|
| 291 | if (idx < 0)
|
| 292 | idx = get_slot_from_bitmask(idx, check_empty_slot, module);
|
| 293 | if (idx < 0)
|
| 294 | err = -ENODEV;
|
| 295 | else if (idx < snd_ecards_limit) {
|
| 296 | if (test_bit(idx, snd_cards_lock))
|
| 297 | err = -EBUSY;
|
| 298 | } else if (idx >= SNDRV_CARDS)
|
| 299 | err = -ENODEV;
|
| 300 | if (!err) {
|
| 301 | set_bit(idx, snd_cards_lock);
|
| 302 | if (idx >= snd_ecards_limit)
|
| 303 | snd_ecards_limit = idx + 1;
|
| 304 | }
|
| 305 | }
|
| 306 | if (err < 0) {
|
| 307 | dev_err(parent, "cannot find the slot for index %d (range 0-%i), error: %d\n",
|
| 308 | idx, snd_ecards_limit - 1, err);
|
| 309 | if (!card->managed)
|
| 310 | kfree(card);
|
| 311 | return err;
|
| 312 | }
|
| 313 | card->dev = get_device(parent);
|
| 314 | card->number = idx;
|
| 315 | WARN_ON(IS_MODULE(CONFIG_SND) && !module);
|
| 316 | card->module = module;
|
| 317 | INIT_LIST_HEAD(&card->devices);
|
| 318 | init_rwsem(&card->controls_rwsem);
|
| 319 | rwlock_init(&card->controls_rwlock);
|
| 320 | INIT_LIST_HEAD(&card->controls);
|
| 321 | INIT_LIST_HEAD(&card->ctl_files);
|
| 322 | #ifdef CONFIG_SND_CTL_FAST_LOOKUP
|
| 323 | xa_init(&card->ctl_numids);
|
| 324 | xa_init(&card->ctl_hash);
|
| 325 | #endif
|
| 326 | spin_lock_init(&card->files_lock);
|
| 327 | INIT_LIST_HEAD(&card->files_list);
|
| 328 | mutex_init(&card->memory_mutex);
|
| 329 | #ifdef CONFIG_PM
|
| 330 | init_waitqueue_head(&card->power_sleep);
|
| 331 | snd_refcount_init(&card->power_ref);
|
| 332 | #endif
|
| 333 | init_waitqueue_head(&card->remove_sleep);
|
| 334 | card->sync_irq = -1;
|
| 335 |
|
| 336 | device_initialize(&card->card_dev);
|
| 337 | card->card_dev.parent = parent;
|
| 338 | card->card_dev.class = &sound_class;
|
| 339 | card->card_dev.release = release_card_device;
|
| 340 | card->card_dev.groups = card->dev_groups;
|
| 341 | card->dev_groups[0] = &card_dev_attr_group;
|
| 342 | err = kobject_set_name(&card->card_dev.kobj, "card%d", idx);
|
| 343 | if (err < 0)
|
| 344 | goto __error;
|
| 345 |
|
| 346 | snprintf(card->irq_descr, sizeof(card->irq_descr), "%s:%s",
|
| 347 | dev_driver_string(card->dev), dev_name(&card->card_dev));
|
| 348 |
|
| 349 |
|
| 350 |
|
| 351 | err = snd_ctl_create(card);
|
| 352 | if (err < 0) {
|
| 353 | dev_err(parent, "unable to register control minors\n");
|
| 354 | goto __error;
|
| 355 | }
|
| 356 | err = snd_info_card_create(card);
|
| 357 | if (err < 0) {
|
| 358 | dev_err(parent, "unable to create card info\n");
|
| 359 | goto __error_ctl;
|
| 360 | }
|
| 361 |
|
| 362 | #ifdef CONFIG_SND_DEBUG
|
| 363 | card->debugfs_root = debugfs_create_dir(dev_name(&card->card_dev),
|
| 364 | sound_debugfs_root);
|
| 365 | #endif
|
| 366 | #ifdef CONFIG_SND_CTL_DEBUG
|
| 367 | card->value_buf = kmalloc_obj(*card->value_buf);
|
| 368 | if (!card->value_buf)
|
| 369 | return -ENOMEM;
|
| 370 | #endif
|
| 371 | return 0;
|
| 372 |
|
| 373 | __error_ctl:
|
| 374 | snd_device_free_all(card);
|
| 375 | __error:
|
| 376 | put_device(&card->card_dev);
|
| 377 | return err;
|
| 378 | }
|
| 379 |
|
| 380 | |
| 381 | * snd_card_ref - Get the card object from the index
|
| 382 | * @idx: the card index
|
| 383 | *
|
| 384 | * Returns a card object corresponding to the given index or NULL if not found.
|
| 385 | * Release the object via snd_card_unref().
|
| 386 | *
|
| 387 | * Return: a card object or NULL
|
| 388 |
|
| 389 | struct snd_card *snd_card_ref(int idx)
|
| 390 | {
|
| 391 | struct snd_card *card;
|
| 392 |
|
| 393 | guard(mutex)(&snd_card_mutex);
|
| 394 | card = snd_cards[idx];
|
| 395 | if (card)
|
| 396 | get_device(&card->card_dev);
|
| 397 | return card;
|
| 398 | }
|
| 399 | EXPORT_SYMBOL_GPL(snd_card_ref);
|
| 400 |
|
| 401 |
|
| 402 | int snd_card_locked(int card)
|
| 403 | {
|
| 404 | guard(mutex)(&snd_card_mutex);
|
| 405 | return test_bit(card, snd_cards_lock);
|
| 406 | }
|
| 407 |
|
| 408 | static loff_t snd_disconnect_llseek(struct file *file, loff_t offset, int orig)
|
| 409 | {
|
| 410 | return -ENODEV;
|
| 411 | }
|
| 412 |
|
| 413 | static ssize_t snd_disconnect_read(struct file *file, char __user *buf,
|
| 414 | size_t count, loff_t *offset)
|
| 415 | {
|
| 416 | return -ENODEV;
|
| 417 | }
|
| 418 |
|
| 419 | static ssize_t snd_disconnect_write(struct file *file, const char __user *buf,
|
| 420 | size_t count, loff_t *offset)
|
| 421 | {
|
| 422 | return -ENODEV;
|
| 423 | }
|
| 424 |
|
| 425 | static int snd_disconnect_release(struct inode *inode, struct file *file)
|
| 426 | {
|
| 427 | struct snd_monitor_file *df = NULL, *_df;
|
| 428 |
|
| 429 | scoped_guard(spinlock, &shutdown_lock) {
|
| 430 | list_for_each_entry(_df, &shutdown_files, shutdown_list) {
|
| 431 | if (_df->file == file) {
|
| 432 | df = _df;
|
| 433 | list_del_init(&df->shutdown_list);
|
| 434 | break;
|
| 435 | }
|
| 436 | }
|
| 437 | }
|
| 438 |
|
| 439 | if (likely(df)) {
|
| 440 | if ((file->f_flags & FASYNC) && df->disconnected_f_op->fasync)
|
| 441 | df->disconnected_f_op->fasync(-1, file, 0);
|
| 442 | return df->disconnected_f_op->release(inode, file);
|
| 443 | }
|
| 444 |
|
| 445 | panic("%s(%p, %p) failed!", __func__, inode, file);
|
| 446 | }
|
| 447 |
|
| 448 | static __poll_t snd_disconnect_poll(struct file * file, poll_table * wait)
|
| 449 | {
|
| 450 | return EPOLLERR | EPOLLNVAL;
|
| 451 | }
|
| 452 |
|
| 453 | static long snd_disconnect_ioctl(struct file *file,
|
| 454 | unsigned int cmd, unsigned long arg)
|
| 455 | {
|
| 456 | return -ENODEV;
|
| 457 | }
|
| 458 |
|
| 459 | static int snd_disconnect_mmap(struct file *file, struct vm_area_struct *vma)
|
| 460 | {
|
| 461 | return -ENODEV;
|
| 462 | }
|
| 463 |
|
| 464 | static int snd_disconnect_fasync(int fd, struct file *file, int on)
|
| 465 | {
|
| 466 | return -ENODEV;
|
| 467 | }
|
| 468 |
|
| 469 | static const struct file_operations snd_shutdown_f_ops = {
|
| 470 | .owner = THIS_MODULE,
|
| 471 | .llseek = snd_disconnect_llseek,
|
| 472 | .read = snd_disconnect_read,
|
| 473 | .write = snd_disconnect_write,
|
| 474 | .release = snd_disconnect_release,
|
| 475 | .poll = snd_disconnect_poll,
|
| 476 | .unlocked_ioctl = snd_disconnect_ioctl,
|
| 477 | #ifdef CONFIG_COMPAT
|
| 478 | .compat_ioctl = snd_disconnect_ioctl,
|
| 479 | #endif
|
| 480 | .mmap = snd_disconnect_mmap,
|
| 481 | .fasync = snd_disconnect_fasync
|
| 482 | };
|
| 483 |
|
| 484 | |
| 485 | * snd_card_disconnect - disconnect all APIs from the file-operations (user space)
|
| 486 | * @card: soundcard structure
|
| 487 | *
|
| 488 | * Disconnects all APIs from the file-operations (user space).
|
| 489 | *
|
| 490 | * Return: Zero, otherwise a negative error code.
|
| 491 | *
|
| 492 | * Note: The current implementation replaces all active file->f_op with special
|
| 493 | * dummy file operations (they do nothing except release).
|
| 494 |
|
| 495 | void snd_card_disconnect(struct snd_card *card)
|
| 496 | {
|
| 497 | struct snd_monitor_file *mfile;
|
| 498 |
|
| 499 | if (!card)
|
| 500 | return;
|
| 501 |
|
| 502 | scoped_guard(spinlock, &card->files_lock) {
|
| 503 | if (card->shutdown)
|
| 504 | return;
|
| 505 | card->shutdown = 1;
|
| 506 |
|
| 507 |
|
| 508 | list_for_each_entry(mfile, &card->files_list, list) {
|
| 509 |
|
| 510 |
|
| 511 | mfile->disconnected_f_op = mfile->file->f_op;
|
| 512 |
|
| 513 | scoped_guard(spinlock, &shutdown_lock)
|
| 514 | list_add(&mfile->shutdown_list, &shutdown_files);
|
| 515 |
|
| 516 | mfile->file->f_op = &snd_shutdown_f_ops;
|
| 517 | fops_get(mfile->file->f_op);
|
| 518 | }
|
| 519 | }
|
| 520 |
|
| 521 | #ifdef CONFIG_PM
|
| 522 | |
| 523 | * deadlocks with other locks (e.g. in kctls);
|
| 524 | * then this notifies the shutdown and sleepers would abort immediately
|
| 525 |
|
| 526 | wake_up_all(&card->power_sleep);
|
| 527 | #endif
|
| 528 |
|
| 529 |
|
| 530 |
|
| 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 |
|
| 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 | #ifdef CONFIG_SND_DEBUG
|
| 545 | debugfs_remove(card->debugfs_root);
|
| 546 | card->debugfs_root = NULL;
|
| 547 | #endif
|
| 548 |
|
| 549 | if (card->registered) {
|
| 550 | device_del(&card->card_dev);
|
| 551 | card->registered = false;
|
| 552 | }
|
| 553 |
|
| 554 |
|
| 555 | scoped_guard(mutex, &snd_card_mutex) {
|
| 556 | snd_cards[card->number] = NULL;
|
| 557 | clear_bit(card->number, snd_cards_lock);
|
| 558 | }
|
| 559 |
|
| 560 | snd_power_sync_ref(card);
|
| 561 | }
|
| 562 | EXPORT_SYMBOL(snd_card_disconnect);
|
| 563 |
|
| 564 | |
| 565 | * snd_card_disconnect_sync - disconnect card and wait until files get closed
|
| 566 | * @card: card object to disconnect
|
| 567 | *
|
| 568 | * This calls snd_card_disconnect() for disconnecting all belonging components
|
| 569 | * and waits until all pending files get closed.
|
| 570 | * It assures that all accesses from user-space finished so that the driver
|
| 571 | * can release its resources gracefully.
|
| 572 |
|
| 573 | void snd_card_disconnect_sync(struct snd_card *card)
|
| 574 | {
|
| 575 | snd_card_disconnect(card);
|
| 576 |
|
| 577 | guard(spinlock_irq)(&card->files_lock);
|
| 578 | wait_event_lock_irq(card->remove_sleep,
|
| 579 | list_empty(&card->files_list),
|
| 580 | card->files_lock);
|
| 581 | }
|
| 582 | EXPORT_SYMBOL_GPL(snd_card_disconnect_sync);
|
| 583 |
|
| 584 | static int snd_card_do_free(struct snd_card *card)
|
| 585 | {
|
| 586 | bool managed = card->managed;
|
| 587 |
|
| 588 | card->releasing = true;
|
| 589 | #if IS_ENABLED(CONFIG_SND_MIXER_OSS)
|
| 590 | if (snd_mixer_oss_notify_callback)
|
| 591 | snd_mixer_oss_notify_callback(card, SND_MIXER_OSS_NOTIFY_FREE);
|
| 592 | #endif
|
| 593 | snd_device_free_all(card);
|
| 594 | kfree(card->components);
|
| 595 | card->components = NULL;
|
| 596 | card->components_alloc_size = 0;
|
| 597 | if (card->private_free)
|
| 598 | card->private_free(card);
|
| 599 | #ifdef CONFIG_SND_CTL_DEBUG
|
| 600 | kfree(card->value_buf);
|
| 601 | #endif
|
| 602 | if (snd_info_card_free(card) < 0) {
|
| 603 | dev_warn(card->dev, "unable to free card info\n");
|
| 604 |
|
| 605 | }
|
| 606 | put_device(card->dev);
|
| 607 | if (card->release_completion)
|
| 608 | complete(card->release_completion);
|
| 609 | if (!managed)
|
| 610 | kfree(card);
|
| 611 | return 0;
|
| 612 | }
|
| 613 |
|
| 614 | |
| 615 | * snd_card_free_when_closed - Disconnect the card, free it later eventually
|
| 616 | * @card: soundcard structure
|
| 617 | *
|
| 618 | * Unlike snd_card_free(), this function doesn't try to release the card
|
| 619 | * resource immediately, but tries to disconnect at first. When the card
|
| 620 | * is still in use, the function returns before freeing the resources.
|
| 621 | * The card resources will be freed when the refcount gets to zero.
|
| 622 | *
|
| 623 | * Return: zero if successful, or a negative error code
|
| 624 |
|
| 625 | void snd_card_free_when_closed(struct snd_card *card)
|
| 626 | {
|
| 627 | if (!card)
|
| 628 | return;
|
| 629 |
|
| 630 | snd_card_disconnect(card);
|
| 631 | put_device(&card->card_dev);
|
| 632 | return;
|
| 633 | }
|
| 634 | EXPORT_SYMBOL(snd_card_free_when_closed);
|
| 635 |
|
| 636 | |
| 637 | * snd_card_free - frees given soundcard structure
|
| 638 | * @card: soundcard structure
|
| 639 | *
|
| 640 | * This function releases the soundcard structure and the all assigned
|
| 641 | * devices automatically. That is, you don't have to release the devices
|
| 642 | * by yourself.
|
| 643 | *
|
| 644 | * This function waits until the all resources are properly released.
|
| 645 | *
|
| 646 | * Return: Zero. Frees all associated devices and frees the control
|
| 647 | * interface associated to given soundcard.
|
| 648 |
|
| 649 | void snd_card_free(struct snd_card *card)
|
| 650 | {
|
| 651 | DECLARE_COMPLETION_ONSTACK(released);
|
| 652 |
|
| 653 | |
| 654 | * a manual call from the driver and the call via devres_free, and
|
| 655 | * we need to avoid double-free. Moreover, the release via devres
|
| 656 | * may call snd_card_free() twice due to its nature, we need to have
|
| 657 | * the check here at the beginning.
|
| 658 |
|
| 659 | if (card->releasing)
|
| 660 | return;
|
| 661 |
|
| 662 | card->release_completion = &released;
|
| 663 | snd_card_free_when_closed(card);
|
| 664 |
|
| 665 |
|
| 666 | wait_for_completion(&released);
|
| 667 | }
|
| 668 | EXPORT_SYMBOL(snd_card_free);
|
| 669 |
|
| 670 |
|
| 671 | static inline bool safe_ascii_char(char c)
|
| 672 | {
|
| 673 | return isascii(c) && isalnum(c);
|
| 674 | }
|
| 675 |
|
| 676 |
|
| 677 | static const char *retrieve_id_from_card_name(const char *name)
|
| 678 | {
|
| 679 | const char *spos = name;
|
| 680 |
|
| 681 | while (*name) {
|
| 682 | if (isspace(*name) && safe_ascii_char(name[1]))
|
| 683 | spos = name + 1;
|
| 684 | name++;
|
| 685 | }
|
| 686 | return spos;
|
| 687 | }
|
| 688 |
|
| 689 |
|
| 690 | static bool card_id_ok(struct snd_card *card, const char *id)
|
| 691 | {
|
| 692 | int i;
|
| 693 | if (!snd_info_check_reserved_words(id))
|
| 694 | return false;
|
| 695 | for (i = 0; i < snd_ecards_limit; i++) {
|
| 696 | if (snd_cards[i] && snd_cards[i] != card &&
|
| 697 | !strcmp(snd_cards[i]->id, id))
|
| 698 | return false;
|
| 699 | }
|
| 700 | return true;
|
| 701 | }
|
| 702 |
|
| 703 |
|
| 704 | static void copy_valid_id_string(struct snd_card *card, const char *src,
|
| 705 | const char *nid)
|
| 706 | {
|
| 707 | char *id = card->id;
|
| 708 |
|
| 709 | while (*nid && !safe_ascii_char(*nid))
|
| 710 | nid++;
|
| 711 | if (isdigit(*nid))
|
| 712 | *id++ = isalpha(*src) ? *src : 'D';
|
| 713 | while (*nid && (size_t)(id - card->id) < sizeof(card->id) - 1) {
|
| 714 | if (safe_ascii_char(*nid))
|
| 715 | *id++ = *nid;
|
| 716 | nid++;
|
| 717 | }
|
| 718 | *id = 0;
|
| 719 | }
|
| 720 |
|
| 721 | |
| 722 | * If the string conflicts with other ids, add a suffix to make it unique.
|
| 723 |
|
| 724 | static void snd_card_set_id_no_lock(struct snd_card *card, const char *src,
|
| 725 | const char *nid)
|
| 726 | {
|
| 727 | int len, loops;
|
| 728 | bool is_default = false;
|
| 729 | char *id;
|
| 730 |
|
| 731 | copy_valid_id_string(card, src, nid);
|
| 732 | id = card->id;
|
| 733 |
|
| 734 | again:
|
| 735 | |
| 736 | * ("card" conflicts with proc directories)
|
| 737 |
|
| 738 | if (!*id || !strncmp(id, "card", 4)) {
|
| 739 | strscpy(card->id, "Default");
|
| 740 | is_default = true;
|
| 741 | }
|
| 742 |
|
| 743 | len = strlen(id);
|
| 744 | for (loops = 0; loops < SNDRV_CARDS; loops++) {
|
| 745 | char sfxstr[5];
|
| 746 | int sfxlen, slen;
|
| 747 |
|
| 748 | if (card_id_ok(card, id))
|
| 749 | return;
|
| 750 |
|
| 751 |
|
| 752 | sfxlen = scnprintf(sfxstr, sizeof(sfxstr), "_%X", loops + 1);
|
| 753 | if (len + sfxlen >= sizeof(card->id))
|
| 754 | slen = sizeof(card->id) - sfxlen - 1;
|
| 755 | else
|
| 756 | slen = len;
|
| 757 | strscpy(id + slen, sfxstr, sizeof(card->id) - slen);
|
| 758 | }
|
| 759 |
|
| 760 | if (!is_default) {
|
| 761 | *id = 0;
|
| 762 | goto again;
|
| 763 | }
|
| 764 |
|
| 765 | dev_err(card->dev, "unable to set card id (%s)\n", id);
|
| 766 | if (card->proc_root->name)
|
| 767 | strscpy(card->id, card->proc_root->name, sizeof(card->id));
|
| 768 | }
|
| 769 |
|
| 770 | |
| 771 | * snd_card_set_id - set card identification name
|
| 772 | * @card: soundcard structure
|
| 773 | * @nid: new identification string
|
| 774 | *
|
| 775 | * This function sets the card identification and checks for name
|
| 776 | * collisions.
|
| 777 |
|
| 778 | void snd_card_set_id(struct snd_card *card, const char *nid)
|
| 779 | {
|
| 780 |
|
| 781 | if (card->id[0] != '\0')
|
| 782 | return;
|
| 783 | guard(mutex)(&snd_card_mutex);
|
| 784 | snd_card_set_id_no_lock(card, nid, nid);
|
| 785 | }
|
| 786 | EXPORT_SYMBOL(snd_card_set_id);
|
| 787 |
|
| 788 | static ssize_t id_show(struct device *dev,
|
| 789 | struct device_attribute *attr, char *buf)
|
| 790 | {
|
| 791 | struct snd_card *card = container_of(dev, struct snd_card, card_dev);
|
| 792 | return sysfs_emit(buf, "%s\n", card->id);
|
| 793 | }
|
| 794 |
|
| 795 | static ssize_t id_store(struct device *dev, struct device_attribute *attr,
|
| 796 | const char *buf, size_t count)
|
| 797 | {
|
| 798 | struct snd_card *card = container_of(dev, struct snd_card, card_dev);
|
| 799 | char buf1[sizeof(card->id)];
|
| 800 | size_t copy = count > sizeof(card->id) - 1 ?
|
| 801 | sizeof(card->id) - 1 : count;
|
| 802 | size_t idx;
|
| 803 | int c;
|
| 804 |
|
| 805 | for (idx = 0; idx < copy; idx++) {
|
| 806 | c = buf[idx];
|
| 807 | if (!safe_ascii_char(c) && c != '_' && c != '-')
|
| 808 | return -EINVAL;
|
| 809 | }
|
| 810 | memcpy(buf1, buf, copy);
|
| 811 | buf1[copy] = '\0';
|
| 812 | guard(mutex)(&snd_card_mutex);
|
| 813 | if (!card_id_ok(NULL, buf1))
|
| 814 | return -EEXIST;
|
| 815 | strscpy(card->id, buf1);
|
| 816 | snd_info_card_id_change(card);
|
| 817 |
|
| 818 | return count;
|
| 819 | }
|
| 820 |
|
| 821 | static DEVICE_ATTR_RW(id);
|
| 822 |
|
| 823 | static ssize_t number_show(struct device *dev,
|
| 824 | struct device_attribute *attr, char *buf)
|
| 825 | {
|
| 826 | struct snd_card *card = container_of(dev, struct snd_card, card_dev);
|
| 827 | return sysfs_emit(buf, "%i\n", card->number);
|
| 828 | }
|
| 829 |
|
| 830 | static DEVICE_ATTR_RO(number);
|
| 831 |
|
| 832 | static struct attribute *card_dev_attrs[] = {
|
| 833 | &dev_attr_id.attr,
|
| 834 | &dev_attr_number.attr,
|
| 835 | NULL
|
| 836 | };
|
| 837 |
|
| 838 | static const struct attribute_group card_dev_attr_group = {
|
| 839 | .attrs = card_dev_attrs,
|
| 840 | };
|
| 841 |
|
| 842 | |
| 843 | * snd_card_add_dev_attr - Append a new sysfs attribute group to card
|
| 844 | * @card: card instance
|
| 845 | * @group: attribute group to append
|
| 846 | *
|
| 847 | * Return: zero if successful, or a negative error code
|
| 848 |
|
| 849 | int snd_card_add_dev_attr(struct snd_card *card,
|
| 850 | const struct attribute_group *group)
|
| 851 | {
|
| 852 | int i;
|
| 853 |
|
| 854 |
|
| 855 | for (i = 0; i < ARRAY_SIZE(card->dev_groups) - 1; i++) {
|
| 856 | if (!card->dev_groups[i]) {
|
| 857 | card->dev_groups[i] = group;
|
| 858 | return 0;
|
| 859 | }
|
| 860 | }
|
| 861 |
|
| 862 | dev_err(card->dev, "Too many groups assigned\n");
|
| 863 | return -ENOSPC;
|
| 864 | }
|
| 865 | EXPORT_SYMBOL_GPL(snd_card_add_dev_attr);
|
| 866 |
|
| 867 | static void trigger_card_free(void *data)
|
| 868 | {
|
| 869 | snd_card_free(data);
|
| 870 | }
|
| 871 |
|
| 872 | |
| 873 | * snd_card_register - register the soundcard
|
| 874 | * @card: soundcard structure
|
| 875 | *
|
| 876 | * This function registers all the devices assigned to the soundcard.
|
| 877 | * Until calling this, the ALSA control interface is blocked from the
|
| 878 | * external accesses. Thus, you should call this function at the end
|
| 879 | * of the initialization of the card.
|
| 880 | *
|
| 881 | * Return: Zero otherwise a negative error code if the registration failed.
|
| 882 |
|
| 883 | int snd_card_register(struct snd_card *card)
|
| 884 | {
|
| 885 | int err;
|
| 886 |
|
| 887 | if (snd_BUG_ON(!card))
|
| 888 | return -EINVAL;
|
| 889 |
|
| 890 | if (!card->registered) {
|
| 891 | err = device_add(&card->card_dev);
|
| 892 | if (err < 0)
|
| 893 | return err;
|
| 894 | card->registered = true;
|
| 895 | } else {
|
| 896 | if (card->managed)
|
| 897 | devm_remove_action(card->dev, trigger_card_free, card);
|
| 898 | }
|
| 899 |
|
| 900 | if (card->managed) {
|
| 901 | err = devm_add_action(card->dev, trigger_card_free, card);
|
| 902 | if (err < 0)
|
| 903 | return err;
|
| 904 | }
|
| 905 |
|
| 906 | err = snd_device_register_all(card);
|
| 907 | if (err < 0)
|
| 908 | return err;
|
| 909 | scoped_guard(mutex, &snd_card_mutex) {
|
| 910 | if (snd_cards[card->number]) {
|
| 911 |
|
| 912 | return snd_info_card_register(card);
|
| 913 | }
|
| 914 | if (*card->id) {
|
| 915 |
|
| 916 | char tmpid[sizeof(card->id)];
|
| 917 |
|
| 918 | memcpy(tmpid, card->id, sizeof(card->id));
|
| 919 | snd_card_set_id_no_lock(card, tmpid, tmpid);
|
| 920 | } else {
|
| 921 |
|
| 922 | const char *src;
|
| 923 |
|
| 924 | src = *card->shortname ? card->shortname : card->longname;
|
| 925 | snd_card_set_id_no_lock(card, src,
|
| 926 | retrieve_id_from_card_name(src));
|
| 927 | }
|
| 928 | snd_cards[card->number] = card;
|
| 929 | }
|
| 930 | err = snd_info_card_register(card);
|
| 931 | if (err < 0)
|
| 932 | return err;
|
| 933 |
|
| 934 | #if IS_ENABLED(CONFIG_SND_MIXER_OSS)
|
| 935 | if (snd_mixer_oss_notify_callback)
|
| 936 | snd_mixer_oss_notify_callback(card, SND_MIXER_OSS_NOTIFY_REGISTER);
|
| 937 | #endif
|
| 938 | return 0;
|
| 939 | }
|
| 940 | EXPORT_SYMBOL(snd_card_register);
|
| 941 |
|
| 942 | #ifdef CONFIG_SND_PROC_FS
|
| 943 | static void snd_card_info_read(struct snd_info_entry *entry,
|
| 944 | struct snd_info_buffer *buffer)
|
| 945 | {
|
| 946 | int idx, count;
|
| 947 | struct snd_card *card;
|
| 948 |
|
| 949 | for (idx = count = 0; idx < SNDRV_CARDS; idx++) {
|
| 950 | guard(mutex)(&snd_card_mutex);
|
| 951 | card = snd_cards[idx];
|
| 952 | if (card) {
|
| 953 | count++;
|
| 954 | snd_iprintf(buffer, "%2i [%-15s]: %s - %s\n",
|
| 955 | idx,
|
| 956 | card->id,
|
| 957 | card->driver,
|
| 958 | card->shortname);
|
| 959 | snd_iprintf(buffer, " %s\n",
|
| 960 | card->longname);
|
| 961 | }
|
| 962 | }
|
| 963 | if (!count)
|
| 964 | snd_iprintf(buffer, "--- no soundcards ---\n");
|
| 965 | }
|
| 966 |
|
| 967 | #ifdef CONFIG_SND_OSSEMUL
|
| 968 | void snd_card_info_read_oss(struct snd_info_buffer *buffer)
|
| 969 | {
|
| 970 | int idx, count;
|
| 971 | struct snd_card *card;
|
| 972 |
|
| 973 | for (idx = count = 0; idx < SNDRV_CARDS; idx++) {
|
| 974 | guard(mutex)(&snd_card_mutex);
|
| 975 | card = snd_cards[idx];
|
| 976 | if (card) {
|
| 977 | count++;
|
| 978 | snd_iprintf(buffer, "%s\n", card->longname);
|
| 979 | }
|
| 980 | }
|
| 981 | if (!count) {
|
| 982 | snd_iprintf(buffer, "--- no soundcards ---\n");
|
| 983 | }
|
| 984 | }
|
| 985 |
|
| 986 | #endif
|
| 987 |
|
| 988 | #ifdef CONFIG_MODULES
|
| 989 | static void snd_card_module_info_read(struct snd_info_entry *entry,
|
| 990 | struct snd_info_buffer *buffer)
|
| 991 | {
|
| 992 | int idx;
|
| 993 | struct snd_card *card;
|
| 994 |
|
| 995 | for (idx = 0; idx < SNDRV_CARDS; idx++) {
|
| 996 | guard(mutex)(&snd_card_mutex);
|
| 997 | card = snd_cards[idx];
|
| 998 | if (card)
|
| 999 | snd_iprintf(buffer, "%2i %s\n",
|
| 1000 | idx, card->module->name);
|
| 1001 | }
|
| 1002 | }
|
| 1003 | #endif
|
| 1004 |
|
| 1005 | int __init snd_card_info_init(void)
|
| 1006 | {
|
| 1007 | struct snd_info_entry *entry;
|
| 1008 |
|
| 1009 | entry = snd_info_create_module_entry(THIS_MODULE, "cards", NULL);
|
| 1010 | if (! entry)
|
| 1011 | return -ENOMEM;
|
| 1012 | entry->c.text.read = snd_card_info_read;
|
| 1013 | if (snd_info_register(entry) < 0)
|
| 1014 | return -ENOMEM;
|
| 1015 |
|
| 1016 | #ifdef CONFIG_MODULES
|
| 1017 | entry = snd_info_create_module_entry(THIS_MODULE, "modules", NULL);
|
| 1018 | if (!entry)
|
| 1019 | return -ENOMEM;
|
| 1020 | entry->c.text.read = snd_card_module_info_read;
|
| 1021 | if (snd_info_register(entry) < 0)
|
| 1022 | return -ENOMEM;
|
| 1023 | #endif
|
| 1024 |
|
| 1025 | return 0;
|
| 1026 | }
|
| 1027 | #endif
|
| 1028 |
|
| 1029 | |
| 1030 | * snd_component_add - add a component string
|
| 1031 | * @card: soundcard structure
|
| 1032 | * @component: the component id string
|
| 1033 | *
|
| 1034 | * This function adds the component id string to the supported list.
|
| 1035 | * The component can be referred from the alsa-lib.
|
| 1036 | *
|
| 1037 | * Return: Zero otherwise a negative error code.
|
| 1038 |
|
| 1039 |
|
| 1040 | int snd_component_add(struct snd_card *card, const char *component)
|
| 1041 | {
|
| 1042 | char *ptr;
|
| 1043 | int len = strlen(component);
|
| 1044 | unsigned int cur_len, need_len;
|
| 1045 |
|
| 1046 | guard(rwsem_write)(&snd_ioctl_rwsem);
|
| 1047 |
|
| 1048 | if (card->components) {
|
| 1049 | ptr = strstr(card->components, component);
|
| 1050 | if (ptr) {
|
| 1051 | if (ptr[len] == '\0' || ptr[len] == ' ')
|
| 1052 | return 1;
|
| 1053 | }
|
| 1054 | cur_len = strlen(card->components) + 1;
|
| 1055 | } else {
|
| 1056 | cur_len = 0;
|
| 1057 | }
|
| 1058 |
|
| 1059 | need_len = cur_len + len + 1;
|
| 1060 | if (need_len > 512) {
|
| 1061 | snd_BUG();
|
| 1062 | return -ENOMEM;
|
| 1063 | }
|
| 1064 |
|
| 1065 | if (need_len > card->components_alloc_size) {
|
| 1066 | unsigned int new_alloc = roundup(need_len, 32);
|
| 1067 |
|
| 1068 | ptr = krealloc(card->components, new_alloc, GFP_KERNEL);
|
| 1069 | if (!ptr)
|
| 1070 | return -ENOMEM;
|
| 1071 | if (!card->components)
|
| 1072 | ptr[0] = '\0';
|
| 1073 | card->components = ptr;
|
| 1074 | card->components_alloc_size = new_alloc;
|
| 1075 | }
|
| 1076 |
|
| 1077 | if (card->components[0] != '\0')
|
| 1078 | strcat(card->components, " ");
|
| 1079 | strcat(card->components, component);
|
| 1080 | return 0;
|
| 1081 | }
|
| 1082 | EXPORT_SYMBOL(snd_component_add);
|
| 1083 |
|
| 1084 | |
| 1085 | * snd_card_file_add - add the file to the file list of the card
|
| 1086 | * @card: soundcard structure
|
| 1087 | * @file: file pointer
|
| 1088 | *
|
| 1089 | * This function adds the file to the file linked-list of the card.
|
| 1090 | * This linked-list is used to keep tracking the connection state,
|
| 1091 | * and to avoid the release of busy resources by hotplug.
|
| 1092 | *
|
| 1093 | * Return: zero or a negative error code.
|
| 1094 |
|
| 1095 | int snd_card_file_add(struct snd_card *card, struct file *file)
|
| 1096 | {
|
| 1097 | struct snd_monitor_file *mfile;
|
| 1098 |
|
| 1099 | mfile = kmalloc_obj(*mfile);
|
| 1100 | if (mfile == NULL)
|
| 1101 | return -ENOMEM;
|
| 1102 | mfile->file = file;
|
| 1103 | mfile->disconnected_f_op = NULL;
|
| 1104 | INIT_LIST_HEAD(&mfile->shutdown_list);
|
| 1105 | guard(spinlock)(&card->files_lock);
|
| 1106 | if (card->shutdown) {
|
| 1107 | kfree(mfile);
|
| 1108 | return -ENODEV;
|
| 1109 | }
|
| 1110 | list_add(&mfile->list, &card->files_list);
|
| 1111 | get_device(&card->card_dev);
|
| 1112 | return 0;
|
| 1113 | }
|
| 1114 | EXPORT_SYMBOL(snd_card_file_add);
|
| 1115 |
|
| 1116 | |
| 1117 | * snd_card_file_remove - remove the file from the file list
|
| 1118 | * @card: soundcard structure
|
| 1119 | * @file: file pointer
|
| 1120 | *
|
| 1121 | * This function removes the file formerly added to the card via
|
| 1122 | * snd_card_file_add() function.
|
| 1123 | * If all files are removed and snd_card_free_when_closed() was
|
| 1124 | * called beforehand, it processes the pending release of
|
| 1125 | * resources.
|
| 1126 | *
|
| 1127 | * Return: Zero or a negative error code.
|
| 1128 |
|
| 1129 | int snd_card_file_remove(struct snd_card *card, struct file *file)
|
| 1130 | {
|
| 1131 | struct snd_monitor_file *mfile, *found = NULL;
|
| 1132 |
|
| 1133 | scoped_guard(spinlock, &card->files_lock) {
|
| 1134 | list_for_each_entry(mfile, &card->files_list, list) {
|
| 1135 | if (mfile->file == file) {
|
| 1136 | list_del(&mfile->list);
|
| 1137 | scoped_guard(spinlock, &shutdown_lock)
|
| 1138 | list_del(&mfile->shutdown_list);
|
| 1139 | if (mfile->disconnected_f_op)
|
| 1140 | fops_put(mfile->disconnected_f_op);
|
| 1141 | found = mfile;
|
| 1142 | break;
|
| 1143 | }
|
| 1144 | }
|
| 1145 | if (list_empty(&card->files_list))
|
| 1146 | wake_up_all(&card->remove_sleep);
|
| 1147 | }
|
| 1148 | if (!found) {
|
| 1149 | dev_err(card->dev, "card file remove problem (%p)\n", file);
|
| 1150 | return -ENOENT;
|
| 1151 | }
|
| 1152 | kfree(found);
|
| 1153 | put_device(&card->card_dev);
|
| 1154 | return 0;
|
| 1155 | }
|
| 1156 | EXPORT_SYMBOL(snd_card_file_remove);
|
| 1157 |
|
| 1158 | #ifdef CONFIG_PM
|
| 1159 | |
| 1160 | * snd_power_ref_and_wait - wait until the card gets powered up
|
| 1161 | * @card: soundcard structure
|
| 1162 | *
|
| 1163 | * Take the power_ref reference count of the given card, and
|
| 1164 | * wait until the card gets powered up to SNDRV_CTL_POWER_D0 state.
|
| 1165 | * The refcount is down again while sleeping until power-up, hence this
|
| 1166 | * function can be used for syncing the floating control ops accesses,
|
| 1167 | * typically around calling control ops.
|
| 1168 | *
|
| 1169 | * The caller needs to pull down the refcount via snd_power_unref() later
|
| 1170 | * when this function returns 0.
|
| 1171 | *
|
| 1172 | * Return: Zero if successful, or a negative error code.
|
| 1173 |
|
| 1174 | int snd_power_ref_and_wait(struct snd_card *card)
|
| 1175 | {
|
| 1176 | snd_power_ref(card);
|
| 1177 | if (snd_power_get_state(card) == SNDRV_CTL_POWER_D0)
|
| 1178 | return 0;
|
| 1179 | wait_event_cmd(card->power_sleep,
|
| 1180 | card->shutdown ||
|
| 1181 | snd_power_get_state(card) == SNDRV_CTL_POWER_D0,
|
| 1182 | snd_power_unref(card), snd_power_ref(card));
|
| 1183 | if (card->shutdown) {
|
| 1184 | snd_power_unref(card);
|
| 1185 | return -ENODEV;
|
| 1186 | }
|
| 1187 | return 0;
|
| 1188 | }
|
| 1189 | EXPORT_SYMBOL_GPL(snd_power_ref_and_wait);
|
| 1190 |
|
| 1191 | |
| 1192 | * snd_power_wait - wait until the card gets powered up (old form)
|
| 1193 | * @card: soundcard structure
|
| 1194 | *
|
| 1195 | * Wait until the card gets powered up to SNDRV_CTL_POWER_D0 state.
|
| 1196 | *
|
| 1197 | * Return: Zero if successful, or a negative error code.
|
| 1198 |
|
| 1199 | int snd_power_wait(struct snd_card *card)
|
| 1200 | {
|
| 1201 | int ret;
|
| 1202 |
|
| 1203 | ret = snd_power_ref_and_wait(card);
|
| 1204 | if (!ret)
|
| 1205 | snd_power_unref(card);
|
| 1206 | return ret;
|
| 1207 | }
|
| 1208 | EXPORT_SYMBOL(snd_power_wait);
|
| 1209 | #endif
|