linux/sound/core/device.c
<<
>>
Prefs
   1/*
   2 *  Device management routines
   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 <sound/driver.h>
  23#include <linux/slab.h>
  24#include <linux/time.h>
  25#include <linux/errno.h>
  26#include <sound/core.h>
  27
  28/**
  29 * snd_device_new - create an ALSA device component
  30 * @card: the card instance
  31 * @type: the device type, SNDRV_DEV_XXX
  32 * @device_data: the data pointer of this device
  33 * @ops: the operator table
  34 *
  35 * Creates a new device component for the given data pointer.
  36 * The device will be assigned to the card and managed together
  37 * by the card.
  38 *
  39 * The data pointer plays a role as the identifier, too, so the
  40 * pointer address must be unique and unchanged.
  41 *
  42 * Returns zero if successful, or a negative error code on failure.
  43 */
  44int snd_device_new(struct snd_card *card, snd_device_type_t type,
  45                   void *device_data, struct snd_device_ops *ops)
  46{
  47        struct snd_device *dev;
  48
  49        snd_assert(card != NULL, return -ENXIO);
  50        snd_assert(device_data != NULL, return -ENXIO);
  51        snd_assert(ops != NULL, return -ENXIO);
  52        dev = kzalloc(sizeof(*dev), GFP_KERNEL);
  53        if (dev == NULL) {
  54                snd_printk(KERN_ERR "Cannot allocate device\n");
  55                return -ENOMEM;
  56        }
  57        dev->card = card;
  58        dev->type = type;
  59        dev->state = SNDRV_DEV_BUILD;
  60        dev->device_data = device_data;
  61        dev->ops = ops;
  62        list_add(&dev->list, &card->devices);   /* add to the head of list */
  63        return 0;
  64}
  65
  66EXPORT_SYMBOL(snd_device_new);
  67
  68/**
  69 * snd_device_free - release the device from the card
  70 * @card: the card instance
  71 * @device_data: the data pointer to release
  72 *
  73 * Removes the device from the list on the card and invokes the
  74 * callbacks, dev_disconnect and dev_free, corresponding to the state.
  75 * Then release the device.
  76 *
  77 * Returns zero if successful, or a negative error code on failure or if the
  78 * device not found.
  79 */
  80int snd_device_free(struct snd_card *card, void *device_data)
  81{
  82        struct snd_device *dev;
  83        
  84        snd_assert(card != NULL, return -ENXIO);
  85        snd_assert(device_data != NULL, return -ENXIO);
  86        list_for_each_entry(dev, &card->devices, list) {
  87                if (dev->device_data != device_data)
  88                        continue;
  89                /* unlink */
  90                list_del(&dev->list);
  91                if (dev->state == SNDRV_DEV_REGISTERED &&
  92                    dev->ops->dev_disconnect)
  93                        if (dev->ops->dev_disconnect(dev))
  94                                snd_printk(KERN_ERR
  95                                           "device disconnect failure\n");
  96                if (dev->ops->dev_free) {
  97                        if (dev->ops->dev_free(dev))
  98                                snd_printk(KERN_ERR "device free failure\n");
  99                }
 100                kfree(dev);
 101                return 0;
 102        }
 103        snd_printd("device free %p (from %p), not found\n", device_data,
 104                   __builtin_return_address(0));
 105        return -ENXIO;
 106}
 107
 108EXPORT_SYMBOL(snd_device_free);
 109
 110/**
 111 * snd_device_disconnect - disconnect the device
 112 * @card: the card instance
 113 * @device_data: the data pointer to disconnect
 114 *
 115 * Turns the device into the disconnection state, invoking
 116 * dev_disconnect callback, if the device was already registered.
 117 *
 118 * Usually called from snd_card_disconnect().
 119 *
 120 * Returns zero if successful, or a negative error code on failure or if the
 121 * device not found.
 122 */
 123int snd_device_disconnect(struct snd_card *card, void *device_data)
 124{
 125        struct snd_device *dev;
 126
 127        snd_assert(card != NULL, return -ENXIO);
 128        snd_assert(device_data != NULL, return -ENXIO);
 129        list_for_each_entry(dev, &card->devices, list) {
 130                if (dev->device_data != device_data)
 131                        continue;
 132                if (dev->state == SNDRV_DEV_REGISTERED &&
 133                    dev->ops->dev_disconnect) {
 134                        if (dev->ops->dev_disconnect(dev))
 135                                snd_printk(KERN_ERR "device disconnect failure\n");
 136                        dev->state = SNDRV_DEV_DISCONNECTED;
 137                }
 138                return 0;
 139        }
 140        snd_printd("device disconnect %p (from %p), not found\n", device_data,
 141                   __builtin_return_address(0));
 142        return -ENXIO;
 143}
 144
 145/**
 146 * snd_device_register - register the device
 147 * @card: the card instance
 148 * @device_data: the data pointer to register
 149 *
 150 * Registers the device which was already created via
 151 * snd_device_new().  Usually this is called from snd_card_register(),
 152 * but it can be called later if any new devices are created after
 153 * invocation of snd_card_register().
 154 *
 155 * Returns zero if successful, or a negative error code on failure or if the
 156 * device not found.
 157 */
 158int snd_device_register(struct snd_card *card, void *device_data)
 159{
 160        struct snd_device *dev;
 161        int err;
 162
 163        snd_assert(card != NULL, return -ENXIO);
 164        snd_assert(device_data != NULL, return -ENXIO);
 165        list_for_each_entry(dev, &card->devices, list) {
 166                if (dev->device_data != device_data)
 167                        continue;
 168                if (dev->state == SNDRV_DEV_BUILD && dev->ops->dev_register) {
 169                        if ((err = dev->ops->dev_register(dev)) < 0)
 170                                return err;
 171                        dev->state = SNDRV_DEV_REGISTERED;
 172                        return 0;
 173                }
 174                snd_printd("snd_device_register busy\n");
 175                return -EBUSY;
 176        }
 177        snd_BUG();
 178        return -ENXIO;
 179}
 180
 181EXPORT_SYMBOL(snd_device_register);
 182
 183/*
 184 * register all the devices on the card.
 185 * called from init.c
 186 */
 187int snd_device_register_all(struct snd_card *card)
 188{
 189        struct snd_device *dev;
 190        int err;
 191        
 192        snd_assert(card != NULL, return -ENXIO);
 193        list_for_each_entry(dev, &card->devices, list) {
 194                if (dev->state == SNDRV_DEV_BUILD && dev->ops->dev_register) {
 195                        if ((err = dev->ops->dev_register(dev)) < 0)
 196                                return err;
 197                        dev->state = SNDRV_DEV_REGISTERED;
 198                }
 199        }
 200        return 0;
 201}
 202
 203/*
 204 * disconnect all the devices on the card.
 205 * called from init.c
 206 */
 207int snd_device_disconnect_all(struct snd_card *card)
 208{
 209        struct snd_device *dev;
 210        int err = 0;
 211
 212        snd_assert(card != NULL, return -ENXIO);
 213        list_for_each_entry(dev, &card->devices, list) {
 214                if (snd_device_disconnect(card, dev->device_data) < 0)
 215                        err = -ENXIO;
 216        }
 217        return err;
 218}
 219
 220/*
 221 * release all the devices on the card.
 222 * called from init.c
 223 */
 224int snd_device_free_all(struct snd_card *card, snd_device_cmd_t cmd)
 225{
 226        struct snd_device *dev;
 227        int err;
 228        unsigned int range_low, range_high;
 229
 230        snd_assert(card != NULL, return -ENXIO);
 231        range_low = cmd * SNDRV_DEV_TYPE_RANGE_SIZE;
 232        range_high = range_low + SNDRV_DEV_TYPE_RANGE_SIZE - 1;
 233      __again:
 234        list_for_each_entry(dev, &card->devices, list) {
 235                if (dev->type >= range_low && dev->type <= range_high) {
 236                        if ((err = snd_device_free(card, dev->device_data)) < 0)
 237                                return err;
 238                        goto __again;
 239                }
 240        }
 241        return 0;
 242}
 243