Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  *  Initialization routines
0004  *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
0005  */
0006 
0007 #include <linux/init.h>
0008 #include <linux/sched.h>
0009 #include <linux/module.h>
0010 #include <linux/device.h>
0011 #include <linux/file.h>
0012 #include <linux/slab.h>
0013 #include <linux/time.h>
0014 #include <linux/ctype.h>
0015 #include <linux/pm.h>
0016 #include <linux/debugfs.h>
0017 #include <linux/completion.h>
0018 #include <linux/interrupt.h>
0019 
0020 #include <sound/core.h>
0021 #include <sound/control.h>
0022 #include <sound/info.h>
0023 
0024 /* monitor files for graceful shutdown (hotplug) */
0025 struct snd_monitor_file {
0026     struct file *file;
0027     const struct file_operations *disconnected_f_op;
0028     struct list_head shutdown_list; /* still need to shutdown */
0029     struct list_head list;  /* link of monitor files */
0030 };
0031 
0032 static DEFINE_SPINLOCK(shutdown_lock);
0033 static LIST_HEAD(shutdown_files);
0034 
0035 static const struct file_operations snd_shutdown_f_ops;
0036 
0037 /* locked for registering/using */
0038 static DECLARE_BITMAP(snd_cards_lock, SNDRV_CARDS);
0039 static struct snd_card *snd_cards[SNDRV_CARDS];
0040 
0041 static DEFINE_MUTEX(snd_card_mutex);
0042 
0043 static char *slots[SNDRV_CARDS];
0044 module_param_array(slots, charp, NULL, 0444);
0045 MODULE_PARM_DESC(slots, "Module names assigned to the slots.");
0046 
0047 /* return non-zero if the given index is reserved for the given
0048  * module via slots option
0049  */
0050 static int module_slot_match(struct module *module, int idx)
0051 {
0052     int match = 1;
0053 #ifdef MODULE
0054     const char *s1, *s2;
0055 
0056     if (!module || !*module->name || !slots[idx])
0057         return 0;
0058 
0059     s1 = module->name;
0060     s2 = slots[idx];
0061     if (*s2 == '!') {
0062         match = 0; /* negative match */
0063         s2++;
0064     }
0065     /* compare module name strings
0066      * hyphens are handled as equivalent with underscore
0067      */
0068     for (;;) {
0069         char c1 = *s1++;
0070         char c2 = *s2++;
0071         if (c1 == '-')
0072             c1 = '_';
0073         if (c2 == '-')
0074             c2 = '_';
0075         if (c1 != c2)
0076             return !match;
0077         if (!c1)
0078             break;
0079     }
0080 #endif /* MODULE */
0081     return match;
0082 }
0083 
0084 #if IS_ENABLED(CONFIG_SND_MIXER_OSS)
0085 int (*snd_mixer_oss_notify_callback)(struct snd_card *card, int free_flag);
0086 EXPORT_SYMBOL(snd_mixer_oss_notify_callback);
0087 #endif
0088 
0089 static int check_empty_slot(struct module *module, int slot)
0090 {
0091     return !slots[slot] || !*slots[slot];
0092 }
0093 
0094 /* return an empty slot number (>= 0) found in the given bitmask @mask.
0095  * @mask == -1 == 0xffffffff means: take any free slot up to 32
0096  * when no slot is available, return the original @mask as is.
0097  */
0098 static int get_slot_from_bitmask(int mask, int (*check)(struct module *, int),
0099                  struct module *module)
0100 {
0101     int slot;
0102 
0103     for (slot = 0; slot < SNDRV_CARDS; slot++) {
0104         if (slot < 32 && !(mask & (1U << slot)))
0105             continue;
0106         if (!test_bit(slot, snd_cards_lock)) {
0107             if (check(module, slot))
0108                 return slot; /* found */
0109         }
0110     }
0111     return mask; /* unchanged */
0112 }
0113 
0114 /* the default release callback set in snd_device_initialize() below;
0115  * this is just NOP for now, as almost all jobs are already done in
0116  * dev_free callback of snd_device chain instead.
0117  */
0118 static void default_release(struct device *dev)
0119 {
0120 }
0121 
0122 /**
0123  * snd_device_initialize - Initialize struct device for sound devices
0124  * @dev: device to initialize
0125  * @card: card to assign, optional
0126  */
0127 void snd_device_initialize(struct device *dev, struct snd_card *card)
0128 {
0129     device_initialize(dev);
0130     if (card)
0131         dev->parent = &card->card_dev;
0132     dev->class = sound_class;
0133     dev->release = default_release;
0134 }
0135 EXPORT_SYMBOL_GPL(snd_device_initialize);
0136 
0137 static int snd_card_init(struct snd_card *card, struct device *parent,
0138              int idx, const char *xid, struct module *module,
0139              size_t extra_size);
0140 static int snd_card_do_free(struct snd_card *card);
0141 static const struct attribute_group card_dev_attr_group;
0142 
0143 static void release_card_device(struct device *dev)
0144 {
0145     snd_card_do_free(dev_to_snd_card(dev));
0146 }
0147 
0148 /**
0149  *  snd_card_new - create and initialize a soundcard structure
0150  *  @parent: the parent device object
0151  *  @idx: card index (address) [0 ... (SNDRV_CARDS-1)]
0152  *  @xid: card identification (ASCII string)
0153  *  @module: top level module for locking
0154  *  @extra_size: allocate this extra size after the main soundcard structure
0155  *  @card_ret: the pointer to store the created card instance
0156  *
0157  *  The function allocates snd_card instance via kzalloc with the given
0158  *  space for the driver to use freely.  The allocated struct is stored
0159  *  in the given card_ret pointer.
0160  *
0161  *  Return: Zero if successful or a negative error code.
0162  */
0163 int snd_card_new(struct device *parent, int idx, const char *xid,
0164             struct module *module, int extra_size,
0165             struct snd_card **card_ret)
0166 {
0167     struct snd_card *card;
0168     int err;
0169 
0170     if (snd_BUG_ON(!card_ret))
0171         return -EINVAL;
0172     *card_ret = NULL;
0173 
0174     if (extra_size < 0)
0175         extra_size = 0;
0176     card = kzalloc(sizeof(*card) + extra_size, GFP_KERNEL);
0177     if (!card)
0178         return -ENOMEM;
0179 
0180     err = snd_card_init(card, parent, idx, xid, module, extra_size);
0181     if (err < 0)
0182         return err; /* card is freed by error handler */
0183 
0184     *card_ret = card;
0185     return 0;
0186 }
0187 EXPORT_SYMBOL(snd_card_new);
0188 
0189 static void __snd_card_release(struct device *dev, void *data)
0190 {
0191     snd_card_free(data);
0192 }
0193 
0194 /**
0195  * snd_devm_card_new - managed snd_card object creation
0196  * @parent: the parent device object
0197  * @idx: card index (address) [0 ... (SNDRV_CARDS-1)]
0198  * @xid: card identification (ASCII string)
0199  * @module: top level module for locking
0200  * @extra_size: allocate this extra size after the main soundcard structure
0201  * @card_ret: the pointer to store the created card instance
0202  *
0203  * This function works like snd_card_new() but manages the allocated resource
0204  * via devres, i.e. you don't need to free explicitly.
0205  *
0206  * When a snd_card object is created with this function and registered via
0207  * snd_card_register(), the very first devres action to call snd_card_free()
0208  * is added automatically.  In that way, the resource disconnection is assured
0209  * at first, then released in the expected order.
0210  *
0211  * If an error happens at the probe before snd_card_register() is called and
0212  * there have been other devres resources, you'd need to free the card manually
0213  * via snd_card_free() call in the error; otherwise it may lead to UAF due to
0214  * devres call orders.  You can use snd_card_free_on_error() helper for
0215  * handling it more easily.
0216  *
0217  * Return: zero if successful, or a negative error code
0218  */
0219 int snd_devm_card_new(struct device *parent, int idx, const char *xid,
0220               struct module *module, size_t extra_size,
0221               struct snd_card **card_ret)
0222 {
0223     struct snd_card *card;
0224     int err;
0225 
0226     *card_ret = NULL;
0227     card = devres_alloc(__snd_card_release, sizeof(*card) + extra_size,
0228                 GFP_KERNEL);
0229     if (!card)
0230         return -ENOMEM;
0231     card->managed = true;
0232     err = snd_card_init(card, parent, idx, xid, module, extra_size);
0233     if (err < 0) {
0234         devres_free(card); /* in managed mode, we need to free manually */
0235         return err;
0236     }
0237 
0238     devres_add(parent, card);
0239     *card_ret = card;
0240     return 0;
0241 }
0242 EXPORT_SYMBOL_GPL(snd_devm_card_new);
0243 
0244 /**
0245  * snd_card_free_on_error - a small helper for handling devm probe errors
0246  * @dev: the managed device object
0247  * @ret: the return code from the probe callback
0248  *
0249  * This function handles the explicit snd_card_free() call at the error from
0250  * the probe callback.  It's just a small helper for simplifying the error
0251  * handling with the managed devices.
0252  *
0253  * Return: zero if successful, or a negative error code
0254  */
0255 int snd_card_free_on_error(struct device *dev, int ret)
0256 {
0257     struct snd_card *card;
0258 
0259     if (!ret)
0260         return 0;
0261     card = devres_find(dev, __snd_card_release, NULL, NULL);
0262     if (card)
0263         snd_card_free(card);
0264     return ret;
0265 }
0266 EXPORT_SYMBOL_GPL(snd_card_free_on_error);
0267 
0268 static int snd_card_init(struct snd_card *card, struct device *parent,
0269              int idx, const char *xid, struct module *module,
0270              size_t extra_size)
0271 {
0272     int err;
0273 #ifdef CONFIG_SND_DEBUG
0274     char name[8];
0275 #endif
0276 
0277     if (extra_size > 0)
0278         card->private_data = (char *)card + sizeof(struct snd_card);
0279     if (xid)
0280         strscpy(card->id, xid, sizeof(card->id));
0281     err = 0;
0282     mutex_lock(&snd_card_mutex);
0283     if (idx < 0) /* first check the matching module-name slot */
0284         idx = get_slot_from_bitmask(idx, module_slot_match, module);
0285     if (idx < 0) /* if not matched, assign an empty slot */
0286         idx = get_slot_from_bitmask(idx, check_empty_slot, module);
0287     if (idx < 0)
0288         err = -ENODEV;
0289     else if (idx < snd_ecards_limit) {
0290         if (test_bit(idx, snd_cards_lock))
0291             err = -EBUSY;   /* invalid */
0292     } else if (idx >= SNDRV_CARDS)
0293         err = -ENODEV;
0294     if (err < 0) {
0295         mutex_unlock(&snd_card_mutex);
0296         dev_err(parent, "cannot find the slot for index %d (range 0-%i), error: %d\n",
0297              idx, snd_ecards_limit - 1, err);
0298         if (!card->managed)
0299             kfree(card); /* manually free here, as no destructor called */
0300         return err;
0301     }
0302     set_bit(idx, snd_cards_lock);       /* lock it */
0303     if (idx >= snd_ecards_limit)
0304         snd_ecards_limit = idx + 1; /* increase the limit */
0305     mutex_unlock(&snd_card_mutex);
0306     card->dev = parent;
0307     card->number = idx;
0308 #ifdef MODULE
0309     WARN_ON(!module);
0310     card->module = module;
0311 #endif
0312     INIT_LIST_HEAD(&card->devices);
0313     init_rwsem(&card->controls_rwsem);
0314     rwlock_init(&card->ctl_files_rwlock);
0315     INIT_LIST_HEAD(&card->controls);
0316     INIT_LIST_HEAD(&card->ctl_files);
0317 #ifdef CONFIG_SND_CTL_FAST_LOOKUP
0318     xa_init(&card->ctl_numids);
0319     xa_init(&card->ctl_hash);
0320 #endif
0321     spin_lock_init(&card->files_lock);
0322     INIT_LIST_HEAD(&card->files_list);
0323     mutex_init(&card->memory_mutex);
0324 #ifdef CONFIG_PM
0325     init_waitqueue_head(&card->power_sleep);
0326     init_waitqueue_head(&card->power_ref_sleep);
0327     atomic_set(&card->power_ref, 0);
0328 #endif
0329     init_waitqueue_head(&card->remove_sleep);
0330     card->sync_irq = -1;
0331 
0332     device_initialize(&card->card_dev);
0333     card->card_dev.parent = parent;
0334     card->card_dev.class = sound_class;
0335     card->card_dev.release = release_card_device;
0336     card->card_dev.groups = card->dev_groups;
0337     card->dev_groups[0] = &card_dev_attr_group;
0338     err = kobject_set_name(&card->card_dev.kobj, "card%d", idx);
0339     if (err < 0)
0340         goto __error;
0341 
0342     snprintf(card->irq_descr, sizeof(card->irq_descr), "%s:%s",
0343          dev_driver_string(card->dev), dev_name(&card->card_dev));
0344 
0345     /* the control interface cannot be accessed from the user space until */
0346     /* snd_cards_bitmask and snd_cards are set with snd_card_register */
0347     err = snd_ctl_create(card);
0348     if (err < 0) {
0349         dev_err(parent, "unable to register control minors\n");
0350         goto __error;
0351     }
0352     err = snd_info_card_create(card);
0353     if (err < 0) {
0354         dev_err(parent, "unable to create card info\n");
0355         goto __error_ctl;
0356     }
0357 
0358 #ifdef CONFIG_SND_DEBUG
0359     sprintf(name, "card%d", idx);
0360     card->debugfs_root = debugfs_create_dir(name, sound_debugfs_root);
0361 #endif
0362     return 0;
0363 
0364       __error_ctl:
0365     snd_device_free_all(card);
0366       __error:
0367     put_device(&card->card_dev);
0368     return err;
0369 }
0370 
0371 /**
0372  * snd_card_ref - Get the card object from the index
0373  * @idx: the card index
0374  *
0375  * Returns a card object corresponding to the given index or NULL if not found.
0376  * Release the object via snd_card_unref().
0377  *
0378  * Return: a card object or NULL
0379  */
0380 struct snd_card *snd_card_ref(int idx)
0381 {
0382     struct snd_card *card;
0383 
0384     mutex_lock(&snd_card_mutex);
0385     card = snd_cards[idx];
0386     if (card)
0387         get_device(&card->card_dev);
0388     mutex_unlock(&snd_card_mutex);
0389     return card;
0390 }
0391 EXPORT_SYMBOL_GPL(snd_card_ref);
0392 
0393 /* return non-zero if a card is already locked */
0394 int snd_card_locked(int card)
0395 {
0396     int locked;
0397 
0398     mutex_lock(&snd_card_mutex);
0399     locked = test_bit(card, snd_cards_lock);
0400     mutex_unlock(&snd_card_mutex);
0401     return locked;
0402 }
0403 
0404 static loff_t snd_disconnect_llseek(struct file *file, loff_t offset, int orig)
0405 {
0406     return -ENODEV;
0407 }
0408 
0409 static ssize_t snd_disconnect_read(struct file *file, char __user *buf,
0410                    size_t count, loff_t *offset)
0411 {
0412     return -ENODEV;
0413 }
0414 
0415 static ssize_t snd_disconnect_write(struct file *file, const char __user *buf,
0416                     size_t count, loff_t *offset)
0417 {
0418     return -ENODEV;
0419 }
0420 
0421 static int snd_disconnect_release(struct inode *inode, struct file *file)
0422 {
0423     struct snd_monitor_file *df = NULL, *_df;
0424 
0425     spin_lock(&shutdown_lock);
0426     list_for_each_entry(_df, &shutdown_files, shutdown_list) {
0427         if (_df->file == file) {
0428             df = _df;
0429             list_del_init(&df->shutdown_list);
0430             break;
0431         }
0432     }
0433     spin_unlock(&shutdown_lock);
0434 
0435     if (likely(df)) {
0436         if ((file->f_flags & FASYNC) && df->disconnected_f_op->fasync)
0437             df->disconnected_f_op->fasync(-1, file, 0);
0438         return df->disconnected_f_op->release(inode, file);
0439     }
0440 
0441     panic("%s(%p, %p) failed!", __func__, inode, file);
0442 }
0443 
0444 static __poll_t snd_disconnect_poll(struct file * file, poll_table * wait)
0445 {
0446     return EPOLLERR | EPOLLNVAL;
0447 }
0448 
0449 static long snd_disconnect_ioctl(struct file *file,
0450                  unsigned int cmd, unsigned long arg)
0451 {
0452     return -ENODEV;
0453 }
0454 
0455 static int snd_disconnect_mmap(struct file *file, struct vm_area_struct *vma)
0456 {
0457     return -ENODEV;
0458 }
0459 
0460 static int snd_disconnect_fasync(int fd, struct file *file, int on)
0461 {
0462     return -ENODEV;
0463 }
0464 
0465 static const struct file_operations snd_shutdown_f_ops =
0466 {
0467     .owner =    THIS_MODULE,
0468     .llseek =   snd_disconnect_llseek,
0469     .read =     snd_disconnect_read,
0470     .write =    snd_disconnect_write,
0471     .release =  snd_disconnect_release,
0472     .poll =     snd_disconnect_poll,
0473     .unlocked_ioctl = snd_disconnect_ioctl,
0474 #ifdef CONFIG_COMPAT
0475     .compat_ioctl = snd_disconnect_ioctl,
0476 #endif
0477     .mmap =     snd_disconnect_mmap,
0478     .fasync =   snd_disconnect_fasync
0479 };
0480 
0481 /**
0482  *  snd_card_disconnect - disconnect all APIs from the file-operations (user space)
0483  *  @card: soundcard structure
0484  *
0485  *  Disconnects all APIs from the file-operations (user space).
0486  *
0487  *  Return: Zero, otherwise a negative error code.
0488  *
0489  *  Note: The current implementation replaces all active file->f_op with special
0490  *        dummy file operations (they do nothing except release).
0491  */
0492 int snd_card_disconnect(struct snd_card *card)
0493 {
0494     struct snd_monitor_file *mfile;
0495 
0496     if (!card)
0497         return -EINVAL;
0498 
0499     spin_lock(&card->files_lock);
0500     if (card->shutdown) {
0501         spin_unlock(&card->files_lock);
0502         return 0;
0503     }
0504     card->shutdown = 1;
0505 
0506     /* replace file->f_op with special dummy operations */
0507     list_for_each_entry(mfile, &card->files_list, list) {
0508         /* it's critical part, use endless loop */
0509         /* we have no room to fail */
0510         mfile->disconnected_f_op = mfile->file->f_op;
0511 
0512         spin_lock(&shutdown_lock);
0513         list_add(&mfile->shutdown_list, &shutdown_files);
0514         spin_unlock(&shutdown_lock);
0515 
0516         mfile->file->f_op = &snd_shutdown_f_ops;
0517         fops_get(mfile->file->f_op);
0518     }
0519     spin_unlock(&card->files_lock); 
0520 
0521     /* notify all connected devices about disconnection */
0522     /* at this point, they cannot respond to any calls except release() */
0523 
0524 #if IS_ENABLED(CONFIG_SND_MIXER_OSS)
0525     if (snd_mixer_oss_notify_callback)
0526         snd_mixer_oss_notify_callback(card, SND_MIXER_OSS_NOTIFY_DISCONNECT);
0527 #endif
0528 
0529     /* notify all devices that we are disconnected */
0530     snd_device_disconnect_all(card);
0531 
0532     if (card->sync_irq > 0)
0533         synchronize_irq(card->sync_irq);
0534 
0535     snd_info_card_disconnect(card);
0536     if (card->registered) {
0537         device_del(&card->card_dev);
0538         card->registered = false;
0539     }
0540 
0541     /* disable fops (user space) operations for ALSA API */
0542     mutex_lock(&snd_card_mutex);
0543     snd_cards[card->number] = NULL;
0544     clear_bit(card->number, snd_cards_lock);
0545     mutex_unlock(&snd_card_mutex);
0546 
0547 #ifdef CONFIG_PM
0548     wake_up(&card->power_sleep);
0549     snd_power_sync_ref(card);
0550 #endif
0551     return 0;   
0552 }
0553 EXPORT_SYMBOL(snd_card_disconnect);
0554 
0555 /**
0556  * snd_card_disconnect_sync - disconnect card and wait until files get closed
0557  * @card: card object to disconnect
0558  *
0559  * This calls snd_card_disconnect() for disconnecting all belonging components
0560  * and waits until all pending files get closed.
0561  * It assures that all accesses from user-space finished so that the driver
0562  * can release its resources gracefully.
0563  */
0564 void snd_card_disconnect_sync(struct snd_card *card)
0565 {
0566     int err;
0567 
0568     err = snd_card_disconnect(card);
0569     if (err < 0) {
0570         dev_err(card->dev,
0571             "snd_card_disconnect error (%d), skipping sync\n",
0572             err);
0573         return;
0574     }
0575 
0576     spin_lock_irq(&card->files_lock);
0577     wait_event_lock_irq(card->remove_sleep,
0578                 list_empty(&card->files_list),
0579                 card->files_lock);
0580     spin_unlock_irq(&card->files_lock);
0581 }
0582 EXPORT_SYMBOL_GPL(snd_card_disconnect_sync);
0583 
0584 static int snd_card_do_free(struct snd_card *card)
0585 {
0586     card->releasing = true;
0587 #if IS_ENABLED(CONFIG_SND_MIXER_OSS)
0588     if (snd_mixer_oss_notify_callback)
0589         snd_mixer_oss_notify_callback(card, SND_MIXER_OSS_NOTIFY_FREE);
0590 #endif
0591     snd_device_free_all(card);
0592     if (card->private_free)
0593         card->private_free(card);
0594     if (snd_info_card_free(card) < 0) {
0595         dev_warn(card->dev, "unable to free card info\n");
0596         /* Not fatal error */
0597     }
0598 #ifdef CONFIG_SND_DEBUG
0599     debugfs_remove(card->debugfs_root);
0600     card->debugfs_root = NULL;
0601 #endif
0602     if (card->release_completion)
0603         complete(card->release_completion);
0604     if (!card->managed)
0605         kfree(card);
0606     return 0;
0607 }
0608 
0609 /**
0610  * snd_card_free_when_closed - Disconnect the card, free it later eventually
0611  * @card: soundcard structure
0612  *
0613  * Unlike snd_card_free(), this function doesn't try to release the card
0614  * resource immediately, but tries to disconnect at first.  When the card
0615  * is still in use, the function returns before freeing the resources.
0616  * The card resources will be freed when the refcount gets to zero.
0617  *
0618  * Return: zero if successful, or a negative error code
0619  */
0620 int snd_card_free_when_closed(struct snd_card *card)
0621 {
0622     int ret = snd_card_disconnect(card);
0623     if (ret)
0624         return ret;
0625     put_device(&card->card_dev);
0626     return 0;
0627 }
0628 EXPORT_SYMBOL(snd_card_free_when_closed);
0629 
0630 /**
0631  * snd_card_free - frees given soundcard structure
0632  * @card: soundcard structure
0633  *
0634  * This function releases the soundcard structure and the all assigned
0635  * devices automatically.  That is, you don't have to release the devices
0636  * by yourself.
0637  *
0638  * This function waits until the all resources are properly released.
0639  *
0640  * Return: Zero. Frees all associated devices and frees the control
0641  * interface associated to given soundcard.
0642  */
0643 int snd_card_free(struct snd_card *card)
0644 {
0645     DECLARE_COMPLETION_ONSTACK(released);
0646     int ret;
0647 
0648     /* The call of snd_card_free() is allowed from various code paths;
0649      * a manual call from the driver and the call via devres_free, and
0650      * we need to avoid double-free. Moreover, the release via devres
0651      * may call snd_card_free() twice due to its nature, we need to have
0652      * the check here at the beginning.
0653      */
0654     if (card->releasing)
0655         return 0;
0656 
0657     card->release_completion = &released;
0658     ret = snd_card_free_when_closed(card);
0659     if (ret)
0660         return ret;
0661     /* wait, until all devices are ready for the free operation */
0662     wait_for_completion(&released);
0663 
0664     return 0;
0665 }
0666 EXPORT_SYMBOL(snd_card_free);
0667 
0668 /* retrieve the last word of shortname or longname */
0669 static const char *retrieve_id_from_card_name(const char *name)
0670 {
0671     const char *spos = name;
0672 
0673     while (*name) {
0674         if (isspace(*name) && isalnum(name[1]))
0675             spos = name + 1;
0676         name++;
0677     }
0678     return spos;
0679 }
0680 
0681 /* return true if the given id string doesn't conflict any other card ids */
0682 static bool card_id_ok(struct snd_card *card, const char *id)
0683 {
0684     int i;
0685     if (!snd_info_check_reserved_words(id))
0686         return false;
0687     for (i = 0; i < snd_ecards_limit; i++) {
0688         if (snd_cards[i] && snd_cards[i] != card &&
0689             !strcmp(snd_cards[i]->id, id))
0690             return false;
0691     }
0692     return true;
0693 }
0694 
0695 /* copy to card->id only with valid letters from nid */
0696 static void copy_valid_id_string(struct snd_card *card, const char *src,
0697                  const char *nid)
0698 {
0699     char *id = card->id;
0700 
0701     while (*nid && !isalnum(*nid))
0702         nid++;
0703     if (isdigit(*nid))
0704         *id++ = isalpha(*src) ? *src : 'D';
0705     while (*nid && (size_t)(id - card->id) < sizeof(card->id) - 1) {
0706         if (isalnum(*nid))
0707             *id++ = *nid;
0708         nid++;
0709     }
0710     *id = 0;
0711 }
0712 
0713 /* Set card->id from the given string
0714  * If the string conflicts with other ids, add a suffix to make it unique.
0715  */
0716 static void snd_card_set_id_no_lock(struct snd_card *card, const char *src,
0717                     const char *nid)
0718 {
0719     int len, loops;
0720     bool is_default = false;
0721     char *id;
0722     
0723     copy_valid_id_string(card, src, nid);
0724     id = card->id;
0725 
0726  again:
0727     /* use "Default" for obviously invalid strings
0728      * ("card" conflicts with proc directories)
0729      */
0730     if (!*id || !strncmp(id, "card", 4)) {
0731         strcpy(id, "Default");
0732         is_default = true;
0733     }
0734 
0735     len = strlen(id);
0736     for (loops = 0; loops < SNDRV_CARDS; loops++) {
0737         char *spos;
0738         char sfxstr[5]; /* "_012" */
0739         int sfxlen;
0740 
0741         if (card_id_ok(card, id))
0742             return; /* OK */
0743 
0744         /* Add _XYZ suffix */
0745         sprintf(sfxstr, "_%X", loops + 1);
0746         sfxlen = strlen(sfxstr);
0747         if (len + sfxlen >= sizeof(card->id))
0748             spos = id + sizeof(card->id) - sfxlen - 1;
0749         else
0750             spos = id + len;
0751         strcpy(spos, sfxstr);
0752     }
0753     /* fallback to the default id */
0754     if (!is_default) {
0755         *id = 0;
0756         goto again;
0757     }
0758     /* last resort... */
0759     dev_err(card->dev, "unable to set card id (%s)\n", id);
0760     if (card->proc_root->name)
0761         strscpy(card->id, card->proc_root->name, sizeof(card->id));
0762 }
0763 
0764 /**
0765  *  snd_card_set_id - set card identification name
0766  *  @card: soundcard structure
0767  *  @nid: new identification string
0768  *
0769  *  This function sets the card identification and checks for name
0770  *  collisions.
0771  */
0772 void snd_card_set_id(struct snd_card *card, const char *nid)
0773 {
0774     /* check if user specified own card->id */
0775     if (card->id[0] != '\0')
0776         return;
0777     mutex_lock(&snd_card_mutex);
0778     snd_card_set_id_no_lock(card, nid, nid);
0779     mutex_unlock(&snd_card_mutex);
0780 }
0781 EXPORT_SYMBOL(snd_card_set_id);
0782 
0783 static ssize_t id_show(struct device *dev,
0784                struct device_attribute *attr, char *buf)
0785 {
0786     struct snd_card *card = container_of(dev, struct snd_card, card_dev);
0787     return sysfs_emit(buf, "%s\n", card->id);
0788 }
0789 
0790 static ssize_t id_store(struct device *dev, struct device_attribute *attr,
0791             const char *buf, size_t count)
0792 {
0793     struct snd_card *card = container_of(dev, struct snd_card, card_dev);
0794     char buf1[sizeof(card->id)];
0795     size_t copy = count > sizeof(card->id) - 1 ?
0796                     sizeof(card->id) - 1 : count;
0797     size_t idx;
0798     int c;
0799 
0800     for (idx = 0; idx < copy; idx++) {
0801         c = buf[idx];
0802         if (!isalnum(c) && c != '_' && c != '-')
0803             return -EINVAL;
0804     }
0805     memcpy(buf1, buf, copy);
0806     buf1[copy] = '\0';
0807     mutex_lock(&snd_card_mutex);
0808     if (!card_id_ok(NULL, buf1)) {
0809         mutex_unlock(&snd_card_mutex);
0810         return -EEXIST;
0811     }
0812     strcpy(card->id, buf1);
0813     snd_info_card_id_change(card);
0814     mutex_unlock(&snd_card_mutex);
0815 
0816     return count;
0817 }
0818 
0819 static DEVICE_ATTR_RW(id);
0820 
0821 static ssize_t number_show(struct device *dev,
0822                struct device_attribute *attr, char *buf)
0823 {
0824     struct snd_card *card = container_of(dev, struct snd_card, card_dev);
0825     return sysfs_emit(buf, "%i\n", card->number);
0826 }
0827 
0828 static DEVICE_ATTR_RO(number);
0829 
0830 static struct attribute *card_dev_attrs[] = {
0831     &dev_attr_id.attr,
0832     &dev_attr_number.attr,
0833     NULL
0834 };
0835 
0836 static const struct attribute_group card_dev_attr_group = {
0837     .attrs  = card_dev_attrs,
0838 };
0839 
0840 /**
0841  * snd_card_add_dev_attr - Append a new sysfs attribute group to card
0842  * @card: card instance
0843  * @group: attribute group to append
0844  *
0845  * Return: zero if successful, or a negative error code
0846  */
0847 int snd_card_add_dev_attr(struct snd_card *card,
0848               const struct attribute_group *group)
0849 {
0850     int i;
0851 
0852     /* loop for (arraysize-1) here to keep NULL at the last entry */
0853     for (i = 0; i < ARRAY_SIZE(card->dev_groups) - 1; i++) {
0854         if (!card->dev_groups[i]) {
0855             card->dev_groups[i] = group;
0856             return 0;
0857         }
0858     }
0859 
0860     dev_err(card->dev, "Too many groups assigned\n");
0861     return -ENOSPC;
0862 }
0863 EXPORT_SYMBOL_GPL(snd_card_add_dev_attr);
0864 
0865 static void trigger_card_free(void *data)
0866 {
0867     snd_card_free(data);
0868 }
0869 
0870 /**
0871  *  snd_card_register - register the soundcard
0872  *  @card: soundcard structure
0873  *
0874  *  This function registers all the devices assigned to the soundcard.
0875  *  Until calling this, the ALSA control interface is blocked from the
0876  *  external accesses.  Thus, you should call this function at the end
0877  *  of the initialization of the card.
0878  *
0879  *  Return: Zero otherwise a negative error code if the registration failed.
0880  */
0881 int snd_card_register(struct snd_card *card)
0882 {
0883     int err;
0884 
0885     if (snd_BUG_ON(!card))
0886         return -EINVAL;
0887 
0888     if (!card->registered) {
0889         err = device_add(&card->card_dev);
0890         if (err < 0)
0891             return err;
0892         card->registered = true;
0893     } else {
0894         if (card->managed)
0895             devm_remove_action(card->dev, trigger_card_free, card);
0896     }
0897 
0898     if (card->managed) {
0899         err = devm_add_action(card->dev, trigger_card_free, card);
0900         if (err < 0)
0901             return err;
0902     }
0903 
0904     err = snd_device_register_all(card);
0905     if (err < 0)
0906         return err;
0907     mutex_lock(&snd_card_mutex);
0908     if (snd_cards[card->number]) {
0909         /* already registered */
0910         mutex_unlock(&snd_card_mutex);
0911         return snd_info_card_register(card); /* register pending info */
0912     }
0913     if (*card->id) {
0914         /* make a unique id name from the given string */
0915         char tmpid[sizeof(card->id)];
0916         memcpy(tmpid, card->id, sizeof(card->id));
0917         snd_card_set_id_no_lock(card, tmpid, tmpid);
0918     } else {
0919         /* create an id from either shortname or longname */
0920         const char *src;
0921         src = *card->shortname ? card->shortname : card->longname;
0922         snd_card_set_id_no_lock(card, src,
0923                     retrieve_id_from_card_name(src));
0924     }
0925     snd_cards[card->number] = card;
0926     mutex_unlock(&snd_card_mutex);
0927     err = snd_info_card_register(card);
0928     if (err < 0)
0929         return err;
0930 
0931 #if IS_ENABLED(CONFIG_SND_MIXER_OSS)
0932     if (snd_mixer_oss_notify_callback)
0933         snd_mixer_oss_notify_callback(card, SND_MIXER_OSS_NOTIFY_REGISTER);
0934 #endif
0935     return 0;
0936 }
0937 EXPORT_SYMBOL(snd_card_register);
0938 
0939 #ifdef CONFIG_SND_PROC_FS
0940 static void snd_card_info_read(struct snd_info_entry *entry,
0941                    struct snd_info_buffer *buffer)
0942 {
0943     int idx, count;
0944     struct snd_card *card;
0945 
0946     for (idx = count = 0; idx < SNDRV_CARDS; idx++) {
0947         mutex_lock(&snd_card_mutex);
0948         card = snd_cards[idx];
0949         if (card) {
0950             count++;
0951             snd_iprintf(buffer, "%2i [%-15s]: %s - %s\n",
0952                     idx,
0953                     card->id,
0954                     card->driver,
0955                     card->shortname);
0956             snd_iprintf(buffer, "                      %s\n",
0957                     card->longname);
0958         }
0959         mutex_unlock(&snd_card_mutex);
0960     }
0961     if (!count)
0962         snd_iprintf(buffer, "--- no soundcards ---\n");
0963 }
0964 
0965 #ifdef CONFIG_SND_OSSEMUL
0966 void snd_card_info_read_oss(struct snd_info_buffer *buffer)
0967 {
0968     int idx, count;
0969     struct snd_card *card;
0970 
0971     for (idx = count = 0; idx < SNDRV_CARDS; idx++) {
0972         mutex_lock(&snd_card_mutex);
0973         card = snd_cards[idx];
0974         if (card) {
0975             count++;
0976             snd_iprintf(buffer, "%s\n", card->longname);
0977         }
0978         mutex_unlock(&snd_card_mutex);
0979     }
0980     if (!count) {
0981         snd_iprintf(buffer, "--- no soundcards ---\n");
0982     }
0983 }
0984 
0985 #endif
0986 
0987 #ifdef MODULE
0988 static void snd_card_module_info_read(struct snd_info_entry *entry,
0989                       struct snd_info_buffer *buffer)
0990 {
0991     int idx;
0992     struct snd_card *card;
0993 
0994     for (idx = 0; idx < SNDRV_CARDS; idx++) {
0995         mutex_lock(&snd_card_mutex);
0996         card = snd_cards[idx];
0997         if (card)
0998             snd_iprintf(buffer, "%2i %s\n",
0999                     idx, card->module->name);
1000         mutex_unlock(&snd_card_mutex);
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; /* freed in error path */
1015 
1016 #ifdef MODULE
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; /* freed in error path */
1023 #endif
1024 
1025     return 0;
1026 }
1027 #endif /* CONFIG_SND_PROC_FS */
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 
1045     ptr = strstr(card->components, component);
1046     if (ptr != NULL) {
1047         if (ptr[len] == '\0' || ptr[len] == ' ')    /* already there */
1048             return 1;
1049     }
1050     if (strlen(card->components) + 1 + len + 1 > sizeof(card->components)) {
1051         snd_BUG();
1052         return -ENOMEM;
1053     }
1054     if (card->components[0] != '\0')
1055         strcat(card->components, " ");
1056     strcat(card->components, component);
1057     return 0;
1058 }
1059 EXPORT_SYMBOL(snd_component_add);
1060 
1061 /**
1062  *  snd_card_file_add - add the file to the file list of the card
1063  *  @card: soundcard structure
1064  *  @file: file pointer
1065  *
1066  *  This function adds the file to the file linked-list of the card.
1067  *  This linked-list is used to keep tracking the connection state,
1068  *  and to avoid the release of busy resources by hotplug.
1069  *
1070  *  Return: zero or a negative error code.
1071  */
1072 int snd_card_file_add(struct snd_card *card, struct file *file)
1073 {
1074     struct snd_monitor_file *mfile;
1075 
1076     mfile = kmalloc(sizeof(*mfile), GFP_KERNEL);
1077     if (mfile == NULL)
1078         return -ENOMEM;
1079     mfile->file = file;
1080     mfile->disconnected_f_op = NULL;
1081     INIT_LIST_HEAD(&mfile->shutdown_list);
1082     spin_lock(&card->files_lock);
1083     if (card->shutdown) {
1084         spin_unlock(&card->files_lock);
1085         kfree(mfile);
1086         return -ENODEV;
1087     }
1088     list_add(&mfile->list, &card->files_list);
1089     get_device(&card->card_dev);
1090     spin_unlock(&card->files_lock);
1091     return 0;
1092 }
1093 EXPORT_SYMBOL(snd_card_file_add);
1094 
1095 /**
1096  *  snd_card_file_remove - remove the file from the file list
1097  *  @card: soundcard structure
1098  *  @file: file pointer
1099  *
1100  *  This function removes the file formerly added to the card via
1101  *  snd_card_file_add() function.
1102  *  If all files are removed and snd_card_free_when_closed() was
1103  *  called beforehand, it processes the pending release of
1104  *  resources.
1105  *
1106  *  Return: Zero or a negative error code.
1107  */
1108 int snd_card_file_remove(struct snd_card *card, struct file *file)
1109 {
1110     struct snd_monitor_file *mfile, *found = NULL;
1111 
1112     spin_lock(&card->files_lock);
1113     list_for_each_entry(mfile, &card->files_list, list) {
1114         if (mfile->file == file) {
1115             list_del(&mfile->list);
1116             spin_lock(&shutdown_lock);
1117             list_del(&mfile->shutdown_list);
1118             spin_unlock(&shutdown_lock);
1119             if (mfile->disconnected_f_op)
1120                 fops_put(mfile->disconnected_f_op);
1121             found = mfile;
1122             break;
1123         }
1124     }
1125     if (list_empty(&card->files_list))
1126         wake_up_all(&card->remove_sleep);
1127     spin_unlock(&card->files_lock);
1128     if (!found) {
1129         dev_err(card->dev, "card file remove problem (%p)\n", file);
1130         return -ENOENT;
1131     }
1132     kfree(found);
1133     put_device(&card->card_dev);
1134     return 0;
1135 }
1136 EXPORT_SYMBOL(snd_card_file_remove);
1137 
1138 #ifdef CONFIG_PM
1139 /**
1140  * snd_power_ref_and_wait - wait until the card gets powered up
1141  * @card: soundcard structure
1142  *
1143  * Take the power_ref reference count of the given card, and
1144  * wait until the card gets powered up to SNDRV_CTL_POWER_D0 state.
1145  * The refcount is down again while sleeping until power-up, hence this
1146  * function can be used for syncing the floating control ops accesses,
1147  * typically around calling control ops.
1148  *
1149  * The caller needs to pull down the refcount via snd_power_unref() later
1150  * no matter whether the error is returned from this function or not.
1151  *
1152  * Return: Zero if successful, or a negative error code.
1153  */
1154 int snd_power_ref_and_wait(struct snd_card *card)
1155 {
1156     snd_power_ref(card);
1157     if (snd_power_get_state(card) == SNDRV_CTL_POWER_D0)
1158         return 0;
1159     wait_event_cmd(card->power_sleep,
1160                card->shutdown ||
1161                snd_power_get_state(card) == SNDRV_CTL_POWER_D0,
1162                snd_power_unref(card), snd_power_ref(card));
1163     return card->shutdown ? -ENODEV : 0;
1164 }
1165 EXPORT_SYMBOL_GPL(snd_power_ref_and_wait);
1166 
1167 /**
1168  * snd_power_wait - wait until the card gets powered up (old form)
1169  * @card: soundcard structure
1170  *
1171  * Wait until the card gets powered up to SNDRV_CTL_POWER_D0 state.
1172  *
1173  * Return: Zero if successful, or a negative error code.
1174  */
1175 int snd_power_wait(struct snd_card *card)
1176 {
1177     int ret;
1178 
1179     ret = snd_power_ref_and_wait(card);
1180     snd_power_unref(card);
1181     return ret;
1182 }
1183 EXPORT_SYMBOL(snd_power_wait);
1184 #endif /* CONFIG_PM */
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!