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 * callback, dev_unregister or 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 list_head *list; 83 struct snd_device *dev; 84 85 snd_assert(card != NULL, return -ENXIO); 86 snd_assert(device_data != NULL, return -ENXIO); 87 list_for_each(list, &card->devices) { 88 dev = snd_device(list); 89 if (dev->device_data != device_data) 90 continue; 91 /* unlink */ 92 list_del(&dev->list); 93 if ((dev->state == SNDRV_DEV_REGISTERED || 94 dev->state == SNDRV_DEV_DISCONNECTED) && 95 dev->ops->dev_unregister) { 96 if (dev->ops->dev_unregister(dev)) 97 snd_printk(KERN_ERR "device unregister failure\n"); 98 } else { 99 if (dev->ops->dev_free) { 100 if (dev->ops->dev_free(dev)) 101 snd_printk(KERN_ERR "device free failure\n"); 102 } 103 } 104 kfree(dev); 105 return 0; 106 } 107 snd_printd("device free %p (from %p), not found\n", device_data, 108 __builtin_return_address(0)); 109 return -ENXIO; 110 } 111 112 EXPORT_SYMBOL(snd_device_free); 113 114 /** 115 * snd_device_disconnect - disconnect the device 116 * @card: the card instance 117 * @device_data: the data pointer to disconnect 118 * 119 * Turns the device into the disconnection state, invoking 120 * dev_disconnect callback, if the device was already registered. 121 * 122 * Usually called from snd_card_disconnect(). 123 * 124 * Returns zero if successful, or a negative error code on failure or if the 125 * device not found. 126 */ 127 int snd_device_disconnect(struct snd_card *card, void *device_data) 128 { 129 struct list_head *list; 130 struct snd_device *dev; 131 132 snd_assert(card != NULL, return -ENXIO); 133 snd_assert(device_data != NULL, return -ENXIO); 134 list_for_each(list, &card->devices) { 135 dev = snd_device(list); 136 if (dev->device_data != device_data) 137 continue; 138 if (dev->state == SNDRV_DEV_REGISTERED && 139 dev->ops->dev_disconnect) { 140 if (dev->ops->dev_disconnect(dev)) 141 snd_printk(KERN_ERR "device disconnect failure\n"); 142 dev->state = SNDRV_DEV_DISCONNECTED; 143 } 144 return 0; 145 } 146 snd_printd("device disconnect %p (from %p), not found\n", device_data, 147 __builtin_return_address(0)); 148 return -ENXIO; 149 } 150 151 /** 152 * snd_device_register - register the device 153 * @card: the card instance 154 * @device_data: the data pointer to register 155 * 156 * Registers the device which was already created via 157 * snd_device_new(). Usually this is called from snd_card_register(), 158 * but it can be called later if any new devices are created after 159 * invocation of snd_card_register(). 160 * 161 * Returns zero if successful, or a negative error code on failure or if the 162 * device not found. 163 */ 164 int snd_device_register(struct snd_card *card, void *device_data) 165 { 166 struct list_head *list; 167 struct snd_device *dev; 168 int err; 169 170 snd_assert(card != NULL, return -ENXIO); 171 snd_assert(device_data != NULL, return -ENXIO); 172 list_for_each(list, &card->devices) { 173 dev = snd_device(list); 174 if (dev->device_data != device_data) 175 continue; 176 if (dev->state == SNDRV_DEV_BUILD && dev->ops->dev_register) { 177 if ((err = dev->ops->dev_register(dev)) < 0) 178 return err; 179 dev->state = SNDRV_DEV_REGISTERED; 180 return 0; 181 } 182 snd_printd("snd_device_register busy\n"); 183 return -EBUSY; 184 } 185 snd_BUG(); 186 return -ENXIO; 187 } 188 189 EXPORT_SYMBOL(snd_device_register); 190 191 /* 192 * register all the devices on the card. 193 * called from init.c 194 */ 195 int snd_device_register_all(struct snd_card *card) 196 { 197 struct list_head *list; 198 struct snd_device *dev; 199 int err; 200 201 snd_assert(card != NULL, return -ENXIO); 202 list_for_each(list, &card->devices) { 203 dev = snd_device(list); 204 if (dev->state == SNDRV_DEV_BUILD && dev->ops->dev_register) { 205 if ((err = dev->ops->dev_register(dev)) < 0) 206 return err; 207 dev->state = SNDRV_DEV_REGISTERED; 208 } 209 } 210 return 0; 211 } 212 213 /* 214 * disconnect all the devices on the card. 215 * called from init.c 216 */ 217 int snd_device_disconnect_all(struct snd_card *card) 218 { 219 struct snd_device *dev; 220 struct list_head *list; 221 int err = 0; 222 223 snd_assert(card != NULL, return -ENXIO); 224 list_for_each(list, &card->devices) { 225 dev = snd_device(list); 226 if (snd_device_disconnect(card, dev->device_data) < 0) 227 err = -ENXIO; 228 } 229 return err; 230 } 231 232 /* 233 * release all the devices on the card. 234 * called from init.c 235 */ 236 int snd_device_free_all(struct snd_card *card, snd_device_cmd_t cmd) 237 { 238 struct snd_device *dev; 239 struct list_head *list; 240 int err; 241 unsigned int range_low, range_high; 242 243 snd_assert(card != NULL, return -ENXIO); 244 range_low = cmd * SNDRV_DEV_TYPE_RANGE_SIZE; 245 range_high = range_low + SNDRV_DEV_TYPE_RANGE_SIZE - 1; 246 __again: 247 list_for_each(list, &card->devices) { 248 dev = snd_device(list); 249 if (dev->type >= range_low && dev->type <= range_high) { 250 if ((err = snd_device_free(card, dev->device_data)) < 0) 251 return err; 252 goto __again; 253 } 254 } 255 return 0; 256 } 257