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