src/async.c

   1 /**
   2  * \file async.c
   3  * \brief Async notification helpers
   4  * \author Abramo Bagnara <abramo@alsa-project.org>
   5  * \date 2001
   6  */
   7 /*
   8  *  Async notification helpers
   9  *  Copyright (c) 2001 by Abramo Bagnara <abramo@alsa-project.org>
  10  *
  11  *   This library is free software; you can redistribute it and/or modify
  12  *   it under the terms of the GNU Lesser General Public License as
  13  *   published by the Free Software Foundation; either version 2.1 of
  14  *   the License, or (at your option) any later version.
  15  *
  16  *   This program is distributed in the hope that it will be useful,
  17  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  *   GNU Lesser General Public License for more details.
  20  *
  21  *   You should have received a copy of the GNU Lesser General Public
  22  *   License along with this library; if not, write to the Free Software
  23  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  24  *
  25  */
  26
  27 #include "pcm/pcm_local.h"
  28 #include "control/control_local.h"
  29 #include <signal.h>
  30
  31 #ifdef SND_ASYNC_RT_SIGNAL
  32 /** async signal number */
  33 static int snd_async_signo;
  34
  35 void snd_async_init(void) __attribute__ ((constructor));
  36
  37 void snd_async_init(void)
  38 {
  39         snd_async_signo = __libc_allocate_rtsig(0);
  40         if (snd_async_signo < 0) {
  41                 SNDERR("Unable to find a RT signal to use for snd_async");
  42                 exit(1);
  43         }
  44 }
  45 #else
  46 /** async signal number */
  47 static const int snd_async_signo = SIGIO;
  48 #endif
  49
  50 static LIST_HEAD(snd_async_handlers);
  51
  52 static void snd_async_handler(int signo ATTRIBUTE_UNUSED, siginfo_t *siginfo, void *context ATTRIBUTE_UNUSED)
  53 {
  54         int fd;
  55         struct list_head *i;
  56         //assert(siginfo->si_code == SI_SIGIO);
  57         fd = siginfo->si_fd;
  58         list_for_each(i, &snd_async_handlers) {
  59                 snd_async_handler_t *h = list_entry(i, snd_async_handler_t, glist);
  60                 if (h->fd == fd && h->callback)
  61                         h->callback(h);
  62         }
  63 }
  64
  65 /**
  66  * \brief Registers an async handler.
  67  * \param handler The function puts the pointer to the new async handler
  68  *                object at the address specified by \p handler.
  69  * \param fd The file descriptor to be associated with the callback.
  70  * \param callback The async callback function.
  71  * \param private_data Private data for the async callback function.
  72  * \result Zero if successful, otherwise a negative error code.
  73  *
  74  * This function associates the callback function with the given file,
  75  * and saves this association in a \c snd_async_handler_t object.
  76  *
  77  * Whenever the \c SIGIO signal is raised for the file \p fd, the callback
  78  * function will be called with its parameter pointing to the async handler
  79  * object returned by this function.
  80  *
  81  * The ALSA \c sigaction handler for the \c SIGIO signal automatically
  82  * multiplexes the notifications to the registered async callbacks.
  83  * However, the application is responsible for instructing the device driver
  84  * to generate the \c SIGIO signal.
  85  *
  86  * The \c SIGIO signal may have been replaced with another signal,
  87  * see #snd_async_handler_get_signo.
  88  *
  89  * When the async handler isn't needed anymore, you must delete it with
  90  * #snd_async_del_handler.
  91  *
  92  * \see snd_async_add_pcm_handler, snd_async_add_ctl_handler
  93  */
  94 int snd_async_add_handler(snd_async_handler_t **handler, int fd,
  95                           snd_async_callback_t callback, void *private_data)
  96 {
  97         snd_async_handler_t *h;
  98         int was_empty;
  99         assert(handler);
 100         h = malloc(sizeof(*h));
 101         if (!h)
 102                 return -ENOMEM;
 103         h->fd = fd;
 104         h->callback = callback;
 105         h->private_data = private_data;
 106         was_empty = list_empty(&snd_async_handlers);
 107         list_add_tail(&h->glist, &snd_async_handlers);
 108         INIT_LIST_HEAD(&h->hlist);
 109         *handler = h;
 110         if (was_empty) {
 111                 int err;
 112                 struct sigaction act;
 113                 memset(&act, 0, sizeof(act));
 114                 act.sa_flags = SA_RESTART | SA_SIGINFO;
 115                 act.sa_sigaction = snd_async_handler;
 116                 sigemptyset(&act.sa_mask);
 117                 err = sigaction(snd_async_signo, &act, NULL);
 118                 if (err < 0) {
 119                         SYSERR("sigaction");
 120                         return -errno;
 121                 }
 122         }
 123         return 0;
 124 }
 125
 126 /**
 127  * \brief Deletes an async handler.
 128  * \param handler Handle of the async handler to delete.
 129  * \result Zero if successful, otherwise a negative error code.
 130  */
 131 int snd_async_del_handler(snd_async_handler_t *handler)
 132 {
 133         int err = 0;
 134         assert(handler);
 135         list_del(&handler->glist);
 136         if (list_empty(&snd_async_handlers)) {
 137                 struct sigaction act;
 138                 memset(&act, 0, sizeof(act));
 139                 act.sa_flags = 0;
 140                 act.sa_handler = SIG_DFL;
 141                 err = sigaction(snd_async_signo, &act, NULL);
 142                 if (err < 0) {
 143                         SYSERR("sigaction");
 144                         return -errno;
 145                 }
 146         }
 147         if (handler->type == SND_ASYNC_HANDLER_GENERIC)
 148                 goto _end;
 149         if (!list_empty(&handler->hlist))
 150                 list_del(&handler->hlist);
 151         if (!list_empty(&handler->hlist))
 152                 goto _end;
 153         switch (handler->type) {
 154 #ifdef BUILD_PCM
 155         case SND_ASYNC_HANDLER_PCM:
 156                 err = snd_pcm_async(handler->u.pcm, -1, 1);
 157                 break;
 158 #endif
 159         case SND_ASYNC_HANDLER_CTL:
 160                 err = snd_ctl_async(handler->u.ctl, -1, 1);
 161                 break;
 162         default:
 163                 assert(0);
 164         }
 165  _end:
 166         free(handler);
 167         return err;
 168 }
 169
 170 /**
 171  * \brief Returns the signal number assigned to an async handler.
 172  * \param handler Handle to an async handler.
 173  * \result The signal number if successful, otherwise a negative error code.
 174  *
 175  * The signal number for async handlers usually is \c SIGIO,
 176  * but wizards can redefine it to a realtime signal
 177  * when compiling the ALSA library.
 178  */
 179 int snd_async_handler_get_signo(snd_async_handler_t *handler)
 180 {
 181         assert(handler);
 182         return snd_async_signo;
 183 }
 184
 185 /**
 186  * \brief Returns the file descriptor assigned to an async handler.
 187  * \param handler Handle to an async handler.
 188  * \result The file descriptor if successful, otherwise a negative error code.
 189  */
 190 int snd_async_handler_get_fd(snd_async_handler_t *handler)
 191 {
 192         assert(handler);
 193         return handler->fd;
 194 }
 195
 196 /**
 197  * \brief Returns the private data assigned to an async handler.
 198  * \param handler Handle to an async handler.
 199  * \result The \c private_data value registered with the async handler.
 200  */
 201 void *snd_async_handler_get_callback_private(snd_async_handler_t *handler)
 202 {
 203         assert(handler);
 204         return handler->private_data;
 205 }
 206