device.c 6.7 KB

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