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 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 66 EXPORT_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 */ 80 int 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 108 EXPORT_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 */ 123 int 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 */ 158 int 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 181 EXPORT_SYMBOL(snd_device_register); 182 183 /* 184 * register all the devices on the card. 185 * called from init.c 186 */ 187 int 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 */ 207 int 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 */ 224 int 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