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 struct list_head *p; 49 50 if (snd_BUG_ON(!card || !device_data || !ops)) 51 return -ENXIO; 52 dev = kzalloc(sizeof(*dev), GFP_KERNEL); 53 if (dev == NULL) { 54 dev_err(card->dev, "Cannot allocate device, type=%d\n", type); 55 return -ENOMEM; 56 } 57 INIT_LIST_HEAD(&dev->list); 58 dev->card = card; 59 dev->type = type; 60 dev->state = SNDRV_DEV_BUILD; 61 dev->device_data = device_data; 62 dev->ops = ops; 63 64 /* insert the entry in an incrementally sorted list */ 65 list_for_each_prev(p, &card->devices) { 66 struct snd_device *pdev = list_entry(p, struct snd_device, list); 67 if ((unsigned int)pdev->type <= (unsigned int)type) 68 break; 69 } 70 71 list_add(&dev->list, p); 72 return 0; 73 } 74 EXPORT_SYMBOL(snd_device_new); 75 76 static int __snd_device_disconnect(struct snd_device *dev) 77 { 78 if (dev->state == SNDRV_DEV_REGISTERED) { 79 if (dev->ops->dev_disconnect && 80 dev->ops->dev_disconnect(dev)) 81 dev_err(dev->card->dev, "device disconnect failure\n"); 82 dev->state = SNDRV_DEV_DISCONNECTED; 83 } 84 return 0; 85 } 86 87 static void __snd_device_free(struct snd_device *dev) 88 { 89 /* unlink */ 90 list_del(&dev->list); 91 92 __snd_device_disconnect(dev); 93 if (dev->ops->dev_free) { 94 if (dev->ops->dev_free(dev)) 95 dev_err(dev->card->dev, "device free failure\n"); 96 } 97 kfree(dev); 98 } 99 100 static struct snd_device *look_for_dev(struct snd_card *card, void *device_data) 101 { 102 struct snd_device *dev; 103 104 list_for_each_entry(dev, &card->devices, list) 105 if (dev->device_data == device_data) 106 return dev; 107 108 return NULL; 109 } 110 111 /** 112 * snd_device_free - release the device from the card 113 * @card: the card instance 114 * @device_data: the data pointer to release 115 * 116 * Removes the device from the list on the card and invokes the 117 * callbacks, dev_disconnect and dev_free, corresponding to the state. 118 * Then release the device. 119 */ 120 void snd_device_free(struct snd_card *card, void *device_data) 121 { 122 struct snd_device *dev; 123 124 if (snd_BUG_ON(!card || !device_data)) 125 return; 126 dev = look_for_dev(card, device_data); 127 if (dev) 128 __snd_device_free(dev); 129 else 130 dev_dbg(card->dev, "device free %p (from %pF), not found\n", 131 device_data, __builtin_return_address(0)); 132 } 133 EXPORT_SYMBOL(snd_device_free); 134 135 static int __snd_device_register(struct snd_device *dev) 136 { 137 if (dev->state == SNDRV_DEV_BUILD) { 138 if (dev->ops->dev_register) { 139 int err = dev->ops->dev_register(dev); 140 if (err < 0) 141 return err; 142 } 143 dev->state = SNDRV_DEV_REGISTERED; 144 } 145 return 0; 146 } 147 148 /** 149 * snd_device_register - register the device 150 * @card: the card instance 151 * @device_data: the data pointer to register 152 * 153 * Registers the device which was already created via 154 * snd_device_new(). Usually this is called from snd_card_register(), 155 * but it can be called later if any new devices are created after 156 * invocation of snd_card_register(). 157 * 158 * Return: Zero if successful, or a negative error code on failure or if the 159 * device not found. 160 */ 161 int snd_device_register(struct snd_card *card, void *device_data) 162 { 163 struct snd_device *dev; 164 165 if (snd_BUG_ON(!card || !device_data)) 166 return -ENXIO; 167 dev = look_for_dev(card, device_data); 168 if (dev) 169 return __snd_device_register(dev); 170 snd_BUG(); 171 return -ENXIO; 172 } 173 EXPORT_SYMBOL(snd_device_register); 174 175 /* 176 * register all the devices on the card. 177 * called from init.c 178 */ 179 int snd_device_register_all(struct snd_card *card) 180 { 181 struct snd_device *dev; 182 int err; 183 184 if (snd_BUG_ON(!card)) 185 return -ENXIO; 186 list_for_each_entry(dev, &card->devices, list) { 187 err = __snd_device_register(dev); 188 if (err < 0) 189 return err; 190 } 191 return 0; 192 } 193 194 /* 195 * disconnect all the devices on the card. 196 * called from init.c 197 */ 198 int snd_device_disconnect_all(struct snd_card *card) 199 { 200 struct snd_device *dev; 201 int err = 0; 202 203 if (snd_BUG_ON(!card)) 204 return -ENXIO; 205 list_for_each_entry_reverse(dev, &card->devices, list) { 206 if (__snd_device_disconnect(dev) < 0) 207 err = -ENXIO; 208 } 209 return err; 210 } 211 212 /* 213 * release all the devices on the card. 214 * called from init.c 215 */ 216 void snd_device_free_all(struct snd_card *card) 217 { 218 struct snd_device *dev, *next; 219 220 if (snd_BUG_ON(!card)) 221 return; 222 list_for_each_entry_safe_reverse(dev, next, &card->devices, list) 223 __snd_device_free(dev); 224 } 225