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/export.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 * Return: Zero if successful, or a negative error code on failure. 43 */ 44 int snd_device_new(struct snd_card *card, enum snd_device_type type, 45 void *device_data, struct snd_device_ops *ops) 46 { 47 struct snd_device *dev; 48 49 if (snd_BUG_ON(!card || !device_data || !ops)) 50 return -ENXIO; 51 dev = kzalloc(sizeof(*dev), GFP_KERNEL); 52 if (dev == NULL) { 53 dev_err(card->dev, "Cannot allocate device, type=%d\n", type); 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 * Return: 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 if (snd_BUG_ON(!card || !device_data)) 84 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 dev_err(card->dev, 94 "device disconnect failure\n"); 95 if (dev->ops->dev_free) { 96 if (dev->ops->dev_free(dev)) 97 dev_err(card->dev, "device free failure\n"); 98 } 99 kfree(dev); 100 return 0; 101 } 102 dev_dbg(card->dev, "device free %p (from %pF), not found\n", 103 device_data, __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 * Return: 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 if (snd_BUG_ON(!card || !device_data)) 127 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 dev_err(card->dev, 135 "device disconnect failure\n"); 136 dev->state = SNDRV_DEV_DISCONNECTED; 137 } 138 return 0; 139 } 140 dev_dbg(card->dev, "device disconnect %p (from %pF), not found\n", 141 device_data, __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 * Return: 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 if (snd_BUG_ON(!card || !device_data)) 164 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 dev_dbg(card->dev, "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 if (snd_BUG_ON(!card)) 193 return -ENXIO; 194 list_for_each_entry(dev, &card->devices, 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 int err = 0; 212 213 if (snd_BUG_ON(!card)) 214 return -ENXIO; 215 list_for_each_entry(dev, &card->devices, list) { 216 if (snd_device_disconnect(card, dev->device_data) < 0) 217 err = -ENXIO; 218 } 219 return err; 220 } 221 222 /* 223 * release all the devices on the card. 224 * called from init.c 225 */ 226 int snd_device_free_all(struct snd_card *card, enum snd_device_cmd cmd) 227 { 228 struct snd_device *dev; 229 int err; 230 unsigned int range_low, range_high, type; 231 232 if (snd_BUG_ON(!card)) 233 return -ENXIO; 234 range_low = (unsigned int)cmd * SNDRV_DEV_TYPE_RANGE_SIZE; 235 range_high = range_low + SNDRV_DEV_TYPE_RANGE_SIZE - 1; 236 __again: 237 list_for_each_entry(dev, &card->devices, list) { 238 type = (unsigned int)dev->type; 239 if (type >= range_low && type <= range_high) { 240 if ((err = snd_device_free(card, dev->device_data)) < 0) 241 return err; 242 goto __again; 243 } 244 } 245 return 0; 246 } 247