linux/sound/core/sound.c
<<
>>
Prefs
   1/*
   2 *  Advanced Linux Sound Architecture
   3 *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
   4 *
   5 *
   6 *   This program is free software; you can redistribute it and/or modify
   7 *   it under the terms of the GNU General Public License as published by
   8 *   the Free Software Foundation; either version 2 of the License, or
   9 *   (at your option) any later version.
  10 *
  11 *   This program is distributed in the hope that it will be useful,
  12 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 *   GNU General Public License for more details.
  15 *
  16 *   You should have received a copy of the GNU General Public License
  17 *   along with this program; if not, write to the Free Software
  18 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 *
  20 */
  21
  22#include <linux/init.h>
  23#include <linux/slab.h>
  24#include <linux/time.h>
  25#include <linux/device.h>
  26#include <linux/module.h>
  27#include <sound/core.h>
  28#include <sound/minors.h>
  29#include <sound/info.h>
  30#include <sound/control.h>
  31#include <sound/initval.h>
  32#include <linux/kmod.h>
  33#include <linux/mutex.h>
  34
  35static int major = CONFIG_SND_MAJOR;
  36int snd_major;
  37EXPORT_SYMBOL(snd_major);
  38
  39static int cards_limit = 1;
  40
  41MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
  42MODULE_DESCRIPTION("Advanced Linux Sound Architecture driver for soundcards.");
  43MODULE_LICENSE("GPL");
  44module_param(major, int, 0444);
  45MODULE_PARM_DESC(major, "Major # for sound driver.");
  46module_param(cards_limit, int, 0444);
  47MODULE_PARM_DESC(cards_limit, "Count of auto-loadable soundcards.");
  48MODULE_ALIAS_CHARDEV_MAJOR(CONFIG_SND_MAJOR);
  49
  50/* this one holds the actual max. card number currently available.
  51 * as default, it's identical with cards_limit option.  when more
  52 * modules are loaded manually, this limit number increases, too.
  53 */
  54int snd_ecards_limit;
  55EXPORT_SYMBOL(snd_ecards_limit);
  56
  57static struct snd_minor *snd_minors[SNDRV_OS_MINORS];
  58static DEFINE_MUTEX(sound_mutex);
  59
  60#ifdef CONFIG_MODULES
  61
  62/**
  63 * snd_request_card - try to load the card module
  64 * @card: the card number
  65 *
  66 * Tries to load the module "snd-card-X" for the given card number
  67 * via request_module.  Returns immediately if already loaded.
  68 */
  69void snd_request_card(int card)
  70{
  71        if (snd_card_locked(card))
  72                return;
  73        if (card < 0 || card >= cards_limit)
  74                return;
  75        request_module("snd-card-%i", card);
  76}
  77
  78EXPORT_SYMBOL(snd_request_card);
  79
  80static void snd_request_other(int minor)
  81{
  82        char *str;
  83
  84        switch (minor) {
  85        case SNDRV_MINOR_SEQUENCER:     str = "snd-seq";        break;
  86        case SNDRV_MINOR_TIMER:         str = "snd-timer";      break;
  87        default:                        return;
  88        }
  89        request_module(str);
  90}
  91
  92#endif  /* modular kernel */
  93
  94/**
  95 * snd_lookup_minor_data - get user data of a registered device
  96 * @minor: the minor number
  97 * @type: device type (SNDRV_DEVICE_TYPE_XXX)
  98 *
  99 * Checks that a minor device with the specified type is registered, and returns
 100 * its user data pointer.
 101 *
 102 * This function increments the reference counter of the card instance
 103 * if an associated instance with the given minor number and type is found.
 104 * The caller must call snd_card_unref() appropriately later.
 105 */
 106void *snd_lookup_minor_data(unsigned int minor, int type)
 107{
 108        struct snd_minor *mreg;
 109        void *private_data;
 110
 111        if (minor >= ARRAY_SIZE(snd_minors))
 112                return NULL;
 113        mutex_lock(&sound_mutex);
 114        mreg = snd_minors[minor];
 115        if (mreg && mreg->type == type) {
 116                private_data = mreg->private_data;
 117                if (private_data && mreg->card_ptr)
 118                        atomic_inc(&mreg->card_ptr->refcount);
 119        } else
 120                private_data = NULL;
 121        mutex_unlock(&sound_mutex);
 122        return private_data;
 123}
 124
 125EXPORT_SYMBOL(snd_lookup_minor_data);
 126
 127#ifdef CONFIG_MODULES
 128static struct snd_minor *autoload_device(unsigned int minor)
 129{
 130        int dev;
 131        mutex_unlock(&sound_mutex); /* release lock temporarily */
 132        dev = SNDRV_MINOR_DEVICE(minor);
 133        if (dev == SNDRV_MINOR_CONTROL) {
 134                /* /dev/aloadC? */
 135                int card = SNDRV_MINOR_CARD(minor);
 136                if (snd_cards[card] == NULL)
 137                        snd_request_card(card);
 138        } else if (dev == SNDRV_MINOR_GLOBAL) {
 139                /* /dev/aloadSEQ */
 140                snd_request_other(minor);
 141        }
 142        mutex_lock(&sound_mutex); /* reacuire lock */
 143        return snd_minors[minor];
 144}
 145#else /* !CONFIG_MODULES */
 146#define autoload_device(minor)  NULL
 147#endif /* CONFIG_MODULES */
 148
 149static int snd_open(struct inode *inode, struct file *file)
 150{
 151        unsigned int minor = iminor(inode);
 152        struct snd_minor *mptr = NULL;
 153        const struct file_operations *old_fops;
 154        int err = 0;
 155
 156        if (minor >= ARRAY_SIZE(snd_minors))
 157                return -ENODEV;
 158        mutex_lock(&sound_mutex);
 159        mptr = snd_minors[minor];
 160        if (mptr == NULL) {
 161                mptr = autoload_device(minor);
 162                if (!mptr) {
 163                        mutex_unlock(&sound_mutex);
 164                        return -ENODEV;
 165                }
 166        }
 167        old_fops = file->f_op;
 168        file->f_op = fops_get(mptr->f_ops);
 169        if (file->f_op == NULL) {
 170                file->f_op = old_fops;
 171                err = -ENODEV;
 172        }
 173        mutex_unlock(&sound_mutex);
 174        if (err < 0)
 175                return err;
 176
 177        if (file->f_op->open) {
 178                err = file->f_op->open(inode, file);
 179                if (err) {
 180                        fops_put(file->f_op);
 181                        file->f_op = fops_get(old_fops);
 182                }
 183        }
 184        fops_put(old_fops);
 185        return err;
 186}
 187
 188static const struct file_operations snd_fops =
 189{
 190        .owner =        THIS_MODULE,
 191        .open =         snd_open,
 192        .llseek =       noop_llseek,
 193};
 194
 195#ifdef CONFIG_SND_DYNAMIC_MINORS
 196static int snd_find_free_minor(int type)
 197{
 198        int minor;
 199
 200        /* static minors for module auto loading */
 201        if (type == SNDRV_DEVICE_TYPE_SEQUENCER)
 202                return SNDRV_MINOR_SEQUENCER;
 203        if (type == SNDRV_DEVICE_TYPE_TIMER)
 204                return SNDRV_MINOR_TIMER;
 205
 206        for (minor = 0; minor < ARRAY_SIZE(snd_minors); ++minor) {
 207                /* skip static minors still used for module auto loading */
 208                if (SNDRV_MINOR_DEVICE(minor) == SNDRV_MINOR_CONTROL)
 209                        continue;
 210                if (minor == SNDRV_MINOR_SEQUENCER ||
 211                    minor == SNDRV_MINOR_TIMER)
 212                        continue;
 213                if (!snd_minors[minor])
 214                        return minor;
 215        }
 216        return -EBUSY;
 217}
 218#else
 219static int snd_kernel_minor(int type, struct snd_card *card, int dev)
 220{
 221        int minor;
 222
 223        switch (type) {
 224        case SNDRV_DEVICE_TYPE_SEQUENCER:
 225        case SNDRV_DEVICE_TYPE_TIMER:
 226                minor = type;
 227                break;
 228        case SNDRV_DEVICE_TYPE_CONTROL:
 229                if (snd_BUG_ON(!card))
 230                        return -EINVAL;
 231                minor = SNDRV_MINOR(card->number, type);
 232                break;
 233        case SNDRV_DEVICE_TYPE_HWDEP:
 234        case SNDRV_DEVICE_TYPE_RAWMIDI:
 235        case SNDRV_DEVICE_TYPE_PCM_PLAYBACK:
 236        case SNDRV_DEVICE_TYPE_PCM_CAPTURE:
 237        case SNDRV_DEVICE_TYPE_COMPRESS:
 238                if (snd_BUG_ON(!card))
 239                        return -EINVAL;
 240                minor = SNDRV_MINOR(card->number, type + dev);
 241                break;
 242        default:
 243                return -EINVAL;
 244        }
 245        if (snd_BUG_ON(minor < 0 || minor >= SNDRV_OS_MINORS))
 246                return -EINVAL;
 247        return minor;
 248}
 249#endif
 250
 251/**
 252 * snd_register_device_for_dev - Register the ALSA device file for the card
 253 * @type: the device type, SNDRV_DEVICE_TYPE_XXX
 254 * @card: the card instance
 255 * @dev: the device index
 256 * @f_ops: the file operations
 257 * @private_data: user pointer for f_ops->open()
 258 * @name: the device file name
 259 * @device: the &struct device to link this new device to
 260 *
 261 * Registers an ALSA device file for the given card.
 262 * The operators have to be set in reg parameter.
 263 *
 264 * Returns zero if successful, or a negative error code on failure.
 265 */
 266int snd_register_device_for_dev(int type, struct snd_card *card, int dev,
 267                                const struct file_operations *f_ops,
 268                                void *private_data,
 269                                const char *name, struct device *device)
 270{
 271        int minor;
 272        struct snd_minor *preg;
 273
 274        if (snd_BUG_ON(!name))
 275                return -EINVAL;
 276        preg = kmalloc(sizeof *preg, GFP_KERNEL);
 277        if (preg == NULL)
 278                return -ENOMEM;
 279        preg->type = type;
 280        preg->card = card ? card->number : -1;
 281        preg->device = dev;
 282        preg->f_ops = f_ops;
 283        preg->private_data = private_data;
 284        preg->card_ptr = card;
 285        mutex_lock(&sound_mutex);
 286#ifdef CONFIG_SND_DYNAMIC_MINORS
 287        minor = snd_find_free_minor(type);
 288#else
 289        minor = snd_kernel_minor(type, card, dev);
 290        if (minor >= 0 && snd_minors[minor])
 291                minor = -EBUSY;
 292#endif
 293        if (minor < 0) {
 294                mutex_unlock(&sound_mutex);
 295                kfree(preg);
 296                return minor;
 297        }
 298        snd_minors[minor] = preg;
 299        preg->dev = device_create(sound_class, device, MKDEV(major, minor),
 300                                  private_data, "%s", name);
 301        if (IS_ERR(preg->dev)) {
 302                snd_minors[minor] = NULL;
 303                mutex_unlock(&sound_mutex);
 304                minor = PTR_ERR(preg->dev);
 305                kfree(preg);
 306                return minor;
 307        }
 308
 309        mutex_unlock(&sound_mutex);
 310        return 0;
 311}
 312
 313EXPORT_SYMBOL(snd_register_device_for_dev);
 314
 315/* find the matching minor record
 316 * return the index of snd_minor, or -1 if not found
 317 */
 318static int find_snd_minor(int type, struct snd_card *card, int dev)
 319{
 320        int cardnum, minor;
 321        struct snd_minor *mptr;
 322
 323        cardnum = card ? card->number : -1;
 324        for (minor = 0; minor < ARRAY_SIZE(snd_minors); ++minor)
 325                if ((mptr = snd_minors[minor]) != NULL &&
 326                    mptr->type == type &&
 327                    mptr->card == cardnum &&
 328                    mptr->device == dev)
 329                        return minor;
 330        return -1;
 331}
 332
 333/**
 334 * snd_unregister_device - unregister the device on the given card
 335 * @type: the device type, SNDRV_DEVICE_TYPE_XXX
 336 * @card: the card instance
 337 * @dev: the device index
 338 *
 339 * Unregisters the device file already registered via
 340 * snd_register_device().
 341 *
 342 * Returns zero if sucecessful, or a negative error code on failure
 343 */
 344int snd_unregister_device(int type, struct snd_card *card, int dev)
 345{
 346        int minor;
 347
 348        mutex_lock(&sound_mutex);
 349        minor = find_snd_minor(type, card, dev);
 350        if (minor < 0) {
 351                mutex_unlock(&sound_mutex);
 352                return -EINVAL;
 353        }
 354
 355        device_destroy(sound_class, MKDEV(major, minor));
 356
 357        kfree(snd_minors[minor]);
 358        snd_minors[minor] = NULL;
 359        mutex_unlock(&sound_mutex);
 360        return 0;
 361}
 362
 363EXPORT_SYMBOL(snd_unregister_device);
 364
 365int snd_add_device_sysfs_file(int type, struct snd_card *card, int dev,
 366                              struct device_attribute *attr)
 367{
 368        int minor, ret = -EINVAL;
 369        struct device *d;
 370
 371        mutex_lock(&sound_mutex);
 372        minor = find_snd_minor(type, card, dev);
 373        if (minor >= 0 && (d = snd_minors[minor]->dev) != NULL)
 374                ret = device_create_file(d, attr);
 375        mutex_unlock(&sound_mutex);
 376        return ret;
 377
 378}
 379
 380EXPORT_SYMBOL(snd_add_device_sysfs_file);
 381
 382#ifdef CONFIG_PROC_FS
 383/*
 384 *  INFO PART
 385 */
 386
 387static struct snd_info_entry *snd_minor_info_entry;
 388
 389static const char *snd_device_type_name(int type)
 390{
 391        switch (type) {
 392        case SNDRV_DEVICE_TYPE_CONTROL:
 393                return "control";
 394        case SNDRV_DEVICE_TYPE_HWDEP:
 395                return "hardware dependent";
 396        case SNDRV_DEVICE_TYPE_RAWMIDI:
 397                return "raw midi";
 398        case SNDRV_DEVICE_TYPE_PCM_PLAYBACK:
 399                return "digital audio playback";
 400        case SNDRV_DEVICE_TYPE_PCM_CAPTURE:
 401                return "digital audio capture";
 402        case SNDRV_DEVICE_TYPE_SEQUENCER:
 403                return "sequencer";
 404        case SNDRV_DEVICE_TYPE_TIMER:
 405                return "timer";
 406        default:
 407                return "?";
 408        }
 409}
 410
 411static void snd_minor_info_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer)
 412{
 413        int minor;
 414        struct snd_minor *mptr;
 415
 416        mutex_lock(&sound_mutex);
 417        for (minor = 0; minor < SNDRV_OS_MINORS; ++minor) {
 418                if (!(mptr = snd_minors[minor]))
 419                        continue;
 420                if (mptr->card >= 0) {
 421                        if (mptr->device >= 0)
 422                                snd_iprintf(buffer, "%3i: [%2i-%2i]: %s\n",
 423                                            minor, mptr->card, mptr->device,
 424                                            snd_device_type_name(mptr->type));
 425                        else
 426                                snd_iprintf(buffer, "%3i: [%2i]   : %s\n",
 427                                            minor, mptr->card,
 428                                            snd_device_type_name(mptr->type));
 429                } else
 430                        snd_iprintf(buffer, "%3i:        : %s\n", minor,
 431                                    snd_device_type_name(mptr->type));
 432        }
 433        mutex_unlock(&sound_mutex);
 434}
 435
 436int __init snd_minor_info_init(void)
 437{
 438        struct snd_info_entry *entry;
 439
 440        entry = snd_info_create_module_entry(THIS_MODULE, "devices", NULL);
 441        if (entry) {
 442                entry->c.text.read = snd_minor_info_read;
 443                if (snd_info_register(entry) < 0) {
 444                        snd_info_free_entry(entry);
 445                        entry = NULL;
 446                }
 447        }
 448        snd_minor_info_entry = entry;
 449        return 0;
 450}
 451
 452int __exit snd_minor_info_done(void)
 453{
 454        snd_info_free_entry(snd_minor_info_entry);
 455        return 0;
 456}
 457#endif /* CONFIG_PROC_FS */
 458
 459/*
 460 *  INIT PART
 461 */
 462
 463static int __init alsa_sound_init(void)
 464{
 465        snd_major = major;
 466        snd_ecards_limit = cards_limit;
 467        if (register_chrdev(major, "alsa", &snd_fops)) {
 468                snd_printk(KERN_ERR "unable to register native major device number %d\n", major);
 469                return -EIO;
 470        }
 471        if (snd_info_init() < 0) {
 472                unregister_chrdev(major, "alsa");
 473                return -ENOMEM;
 474        }
 475        snd_info_minor_register();
 476#ifndef MODULE
 477        printk(KERN_INFO "Advanced Linux Sound Architecture Driver Initialized.\n");
 478#endif
 479        return 0;
 480}
 481
 482static void __exit alsa_sound_exit(void)
 483{
 484        snd_info_minor_unregister();
 485        snd_info_done();
 486        unregister_chrdev(major, "alsa");
 487}
 488
 489subsys_initcall(alsa_sound_init);
 490module_exit(alsa_sound_exit);
 491
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.