sound/core/device.c

   1 /*
   2  *  Device management routines
   3  *  Copyright (c) by Jaroslav Kysela <perex@suse.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  */
  44 int 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                 return -ENOMEM;
  55         dev->card = card;
  56         dev->type = type;
  57         dev->state = SNDRV_DEV_BUILD;
  58         dev->device_data = device_data;
  59         dev->ops = ops;
  60         list_add(&dev->list, &card->devices);   /* add to the head of list */
  61         return 0;
  62 }
  63
  64 /**
  65  * snd_device_free - release the device from the card
  66  * @card: the card instance
  67  * @device_data: the data pointer to release
  68  *
  69  * Removes the device from the list on the card and invokes the
  70  * callback, dev_unregister or dev_free, corresponding to the state.
  71  * Then release the device.
  72  *
  73  * Returns zero if successful, or a negative error code on failure or if the
  74  * device not found.
  75  */
  76 int snd_device_free(struct snd_card *card, void *device_data)
  77 {
  78         struct list_head *list;
  79         struct snd_device *dev;
  80
  81         snd_assert(card != NULL, return -ENXIO);
  82         snd_assert(device_data != NULL, return -ENXIO);
  83         list_for_each(list, &card->devices) {
  84                 dev = snd_device(list);
  85                 if (dev->device_data != device_data)
  86                         continue;
  87                 /* unlink */
  88                 list_del(&dev->list);
  89                 if ((dev->state == SNDRV_DEV_REGISTERED ||
  90                      dev->state == SNDRV_DEV_DISCONNECTED) &&
  91                     dev->ops->dev_unregister) {
  92                         if (dev->ops->dev_unregister(dev))
  93                                 snd_printk(KERN_ERR "device unregister failure\n");
  94                 } else {
  95                         if (dev->ops->dev_free) {
  96                                 if (dev->ops->dev_free(dev))
  97                                         snd_printk(KERN_ERR "device free failure\n");
  98                         }
  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
 108 /**
 109  * snd_device_disconnect - disconnect the device
 110  * @card: the card instance
 111  * @device_data: the data pointer to disconnect
 112  *
 113  * Turns the device into the disconnection state, invoking
 114  * dev_disconnect callback, if the device was already registered.
 115  *
 116  * Usually called from snd_card_disconnect().
 117  *
 118  * Returns zero if successful, or a negative error code on failure or if the
 119  * device not found.
 120  */
 121 int snd_device_disconnect(struct snd_card *card, void *device_data)
 122 {
 123         struct list_head *list;
 124         struct snd_device *dev;
 125
 126         snd_assert(card != NULL, return -ENXIO);
 127         snd_assert(device_data != NULL, return -ENXIO);
 128         list_for_each(list, &card->devices) {
 129                 dev = snd_device(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  */
 158 int snd_device_register(struct snd_card *card, void *device_data)
 159 {
 160         struct list_head *list;
 161         struct snd_device *dev;
 162         int err;
 163
 164         snd_assert(card != NULL, return -ENXIO);
 165         snd_assert(device_data != NULL, return -ENXIO);
 166         list_for_each(list, &card->devices) {
 167                 dev = snd_device(list);
 168                 if (dev->device_data != device_data)
 169                         continue;
 170                 if (dev->state == SNDRV_DEV_BUILD && dev->ops->dev_register) {
 171                         if ((err = dev->ops->dev_register(dev)) < 0)
 172                                 return err;
 173                         dev->state = SNDRV_DEV_REGISTERED;
 174                         return 0;
 175                 }
 176                 return -EBUSY;
 177         }
 178         snd_BUG();
 179         return -ENXIO;
 180 }
 181
 182 /*
 183  * register all the devices on the card.
 184  * called from init.c
 185  */
 186 int snd_device_register_all(struct snd_card *card)
 187 {
 188         struct list_head *list;
 189         struct snd_device *dev;
 190         int err;
 191
 192         snd_assert(card != NULL, return -ENXIO);
 193         list_for_each(list, &card->devices) {
 194                 dev = snd_device(list);
 195                 if (dev->state == SNDRV_DEV_BUILD && dev->ops->dev_register) {
 196                         if ((err = dev->ops->dev_register(dev)) < 0)
 197                                 return err;
 198                         dev->state = SNDRV_DEV_REGISTERED;
 199                 }
 200         }
 201         return 0;
 202 }
 203
 204 /*
 205  * disconnect all the devices on the card.
 206  * called from init.c
 207  */
 208 int snd_device_disconnect_all(struct snd_card *card)
 209 {
 210         struct snd_device *dev;
 211         struct list_head *list;
 212         int err = 0;
 213
 214         snd_assert(card != NULL, return -ENXIO);
 215         list_for_each(list, &card->devices) {
 216                 dev = snd_device(list);
 217                 if (snd_device_disconnect(card, dev->device_data) < 0)
 218                         err = -ENXIO;
 219         }
 220         return err;
 221 }
 222
 223 /*
 224  * release all the devices on the card.
 225  * called from init.c
 226  */
 227 int snd_device_free_all(struct snd_card *card, snd_device_cmd_t cmd)
 228 {
 229         struct snd_device *dev;
 230         struct list_head *list;
 231         int err;
 232         unsigned int range_low, range_high;
 233
 234         snd_assert(card != NULL, return -ENXIO);
 235         range_low = cmd * SNDRV_DEV_TYPE_RANGE_SIZE;
 236         range_high = range_low + SNDRV_DEV_TYPE_RANGE_SIZE - 1;
 237       __again:
 238         list_for_each(list, &card->devices) {
 239                 dev = snd_device(list);
 240                 if (dev->type >= range_low && dev->type <= range_high) {
 241                         if ((err = snd_device_free(card, dev->device_data)) < 0)
 242                                 return err;
 243                         goto __again;
 244                 }
 245         }
 246         return 0;
 247 }