hardware/alsa/alsa.c

   1 /*
   2  * This file is part of the sigrok project.
   3  *
   4  * Copyright (C) 2011 Daniel Ribeiro <drwyrm@gmail.com>
   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., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
  19  */
  20
  21 #include <stdlib.h>
  22 #include <unistd.h>
  23 #include <string.h>
  24 #include <sigrok.h>
  25 #include <alsa/asoundlib.h>
  26 #include "config.h"
  27
  28 #define NUM_PROBES 2
  29 #define SAMPLE_WIDTH 16
  30 #define AUDIO_DEV "plughw:0,0"
  31
  32 static int capabilities[] = {
  33         HWCAP_SAMPLERATE,
  34         HWCAP_LIMIT_SAMPLES,
  35         HWCAP_CONTINUOUS,
  36 };
  37
  38 static GSList *device_instances = NULL;
  39
  40 struct alsa {
  41         uint64_t cur_rate;
  42         uint64_t limit_samples;
  43         snd_pcm_t *capture_handle;
  44         snd_pcm_hw_params_t *hw_params;
  45         gpointer session_id;
  46 };
  47
  48 static int hw_init(char *deviceinfo)
  49 {
  50         struct sigrok_device_instance *sdi;
  51         struct alsa *alsa;
  52
  53         /* Avoid compiler warnings. */
  54         deviceinfo = deviceinfo;
  55
  56         alsa = malloc(sizeof(struct alsa));
  57         if (!alsa)
  58                 return 0;
  59         memset(alsa, 0, sizeof(struct alsa));
  60
  61         sdi = sigrok_device_instance_new(0, ST_ACTIVE, "alsa", NULL, NULL);
  62         if (!sdi)
  63                 goto free_alsa;
  64
  65         sdi->priv = alsa;
  66
  67         device_instances = g_slist_append(device_instances, sdi);
  68
  69         return 1;
  70 free_alsa:
  71         free(alsa);
  72         return 0;
  73 }
  74
  75 static int hw_opendev(int device_index)
  76 {
  77         struct sigrok_device_instance *sdi;
  78         struct alsa *alsa;
  79         int err;
  80
  81         if (!(sdi = get_sigrok_device_instance(device_instances, 0)))
  82                 return SIGROK_ERR;
  83         alsa = sdi->priv;
  84
  85         err = snd_pcm_open(&alsa->capture_handle, AUDIO_DEV,
  86                                         SND_PCM_STREAM_CAPTURE, 0);
  87         if (err < 0) {
  88                 g_warning("cannot open audio device %s (%s)", AUDIO_DEV,
  89                                 snd_strerror(err));
  90                 return SIGROK_ERR;
  91         }
  92
  93         err = snd_pcm_hw_params_malloc(&alsa->hw_params);
  94         if (err < 0) {
  95                 g_warning("cannot allocate hardware parameter structure (%s)",
  96                                 snd_strerror(err));
  97                 return SIGROK_ERR;
  98         }
  99
 100         err = snd_pcm_hw_params_any(alsa->capture_handle, alsa->hw_params);
 101         if (err < 0) {
 102                 g_warning("cannot initialize hardware parameter structure (%s)",
 103                                 snd_strerror(err));
 104                 return SIGROK_ERR;
 105         }
 106
 107         return SIGROK_OK;
 108 }
 109
 110 static void hw_closedev(int device_index)
 111 {
 112         struct sigrok_device_instance *sdi;
 113         struct alsa *alsa;
 114
 115         if (!(sdi = get_sigrok_device_instance(device_instances, 0)))
 116                 return;
 117         alsa = sdi->priv;
 118         if (!alsa)
 119                 return;
 120
 121         if (alsa->hw_params)
 122                 snd_pcm_hw_params_free(alsa->hw_params);
 123         if (alsa->capture_handle)
 124                 snd_pcm_close(alsa->capture_handle);
 125 }
 126
 127 static void hw_cleanup(void)
 128 {
 129         struct sigrok_device_instance *sdi;
 130
 131         if (!(sdi = get_sigrok_device_instance(device_instances, 0)))
 132                 return;
 133
 134         free(sdi->priv);
 135         sigrok_device_instance_free(sdi);
 136 }
 137
 138 static void *hw_get_device_info(int device_index, int device_info_id)
 139 {
 140         struct sigrok_device_instance *sdi;
 141         struct alsa *alsa;
 142         void *info = NULL;
 143
 144         if (!(sdi = get_sigrok_device_instance(device_instances, device_index)))
 145                 return NULL;
 146         alsa = sdi->priv;
 147
 148         switch (device_info_id) {
 149         case DI_INSTANCE:
 150                 info = sdi;
 151                 break;
 152         case DI_NUM_PROBES:
 153                 info = GINT_TO_POINTER(NUM_PROBES);
 154                 break;
 155         case DI_CUR_SAMPLERATE:
 156                 info = &alsa->cur_rate;
 157                 break;
 158         case DI_PROBE_TYPE:
 159                 info = GINT_TO_POINTER(PROBE_TYPE_ANALOG);
 160                 break;
 161         }
 162
 163         return info;
 164 }
 165
 166 static int hw_get_status(int device_index)
 167 {
 168         /* Avoid compiler warnings. */
 169         device_index = device_index;
 170
 171         return ST_ACTIVE;
 172 }
 173
 174 static int *hw_get_capabilities(void)
 175 {
 176         return capabilities;
 177 }
 178
 179 static int hw_set_configuration(int device_index, int capability, void *value)
 180 {
 181         struct sigrok_device_instance *sdi;
 182         struct alsa *alsa;
 183
 184         if (!(sdi = get_sigrok_device_instance(device_instances, device_index)))
 185                 return SIGROK_ERR;
 186         alsa = sdi->priv;
 187
 188         switch (capability) {
 189         case HWCAP_PROBECONFIG:
 190                 return SIGROK_OK;
 191         case HWCAP_SAMPLERATE:
 192                 alsa->cur_rate = *(uint64_t *) value;
 193                 return SIGROK_OK;
 194         case HWCAP_LIMIT_SAMPLES:
 195                 alsa->limit_samples = *(uint64_t *) value;
 196                 return SIGROK_OK;
 197         default:
 198                 return SIGROK_ERR;
 199         }
 200 }
 201
 202 /*
 203  * FIXME: This is incomplete, i couldn't get poll() to work with alsa fds yet.
 204  */
 205 static int receive_data(int fd, int revents, void *user_data)
 206 {
 207         struct sigrok_device_instance *sdi = user_data;
 208         struct alsa *alsa = sdi->priv;
 209         struct datafeed_packet packet;
 210         char buf[128];
 211         int i, err;
 212
 213         g_warning("entered receive_data");
 214
 215         for (i = 0; i < 10; i++) {
 216                 if ((err = snd_pcm_readi(alsa->capture_handle, buf, 128)) != 128) {
 217                         g_warning("read from audio interface failed (%s)\n",
 218                                  snd_strerror(err));
 219                         return FALSE;
 220                 }
 221                 g_warning("data read ok");
 222         }
 223
 224         return TRUE;
 225 }
 226
 227 static int hw_start_acquisition(int device_index, gpointer session_device_id)
 228 {
 229         struct sigrok_device_instance *sdi;
 230         struct alsa *alsa;
 231         struct datafeed_packet packet;
 232         struct datafeed_header header;
 233         struct pollfd *ufds;
 234         int count;
 235         int err;
 236
 237         if (!(sdi = get_sigrok_device_instance(device_instances, device_index)))
 238                 return SIGROK_ERR;
 239         alsa = sdi->priv;
 240
 241         err = snd_pcm_hw_params_set_access(alsa->capture_handle,
 242                         alsa->hw_params, SND_PCM_ACCESS_RW_INTERLEAVED);
 243         if (err < 0) {
 244                 g_warning("cannot set access type (%s)", snd_strerror(err));
 245                 return SIGROK_ERR;
 246         }
 247
 248         /* FIXME: Hardcoded for 16bits */
 249         err = snd_pcm_hw_params_set_format(alsa->capture_handle,
 250                         alsa->hw_params, SND_PCM_FORMAT_S16_LE);
 251         if (err < 0) {
 252                 g_warning("cannot set sample format (%s)", snd_strerror(err));
 253                 return SIGROK_ERR;
 254         }
 255
 256         err = snd_pcm_hw_params_set_rate_near(alsa->capture_handle,
 257                         alsa->hw_params, (unsigned int *) &alsa->cur_rate, 0);
 258         if (err < 0) {
 259                 g_warning("cannot set sample rate (%s)", snd_strerror(err));
 260                 return SIGROK_ERR;
 261         }
 262
 263         err = snd_pcm_hw_params_set_channels(alsa->capture_handle,
 264                         alsa->hw_params, NUM_PROBES);
 265         if (err < 0) {
 266                 g_warning("cannot set channel count (%s)", snd_strerror(err));
 267                 return SIGROK_ERR;
 268         }
 269
 270         err = snd_pcm_hw_params(alsa->capture_handle, alsa->hw_params);
 271         if (err < 0) {
 272                 g_warning("cannot set parameters (%s)", snd_strerror(err));
 273                 return SIGROK_ERR;
 274         }
 275
 276         err = snd_pcm_prepare(alsa->capture_handle);
 277         if (err < 0) {
 278                 g_warning("cannot prepare audio interface for use (%s)",
 279                                 snd_strerror(err));
 280                 return SIGROK_ERR;
 281         }
 282
 283         count = snd_pcm_poll_descriptors_count(alsa->capture_handle);
 284         if (count < 1) {
 285                 g_warning("Unable to obtain poll descriptors count");
 286                 return SIGROK_ERR;
 287         }
 288
 289         ufds = malloc(count * sizeof(struct pollfd));
 290         if (!ufds)
 291                 return SIGROK_ERR_MALLOC;
 292
 293         err = snd_pcm_poll_descriptors(alsa->capture_handle, ufds, count);
 294         if (err < 0) {
 295                 g_warning("Unable to obtain poll descriptors (%s)",
 296                                 snd_strerror(err));
 297                 free(ufds);
 298                 return SIGROK_ERR;
 299         }
 300
 301         alsa->session_id = session_device_id;
 302         source_add(ufds[0].fd, ufds[0].revents, -1, receive_data, sdi);
 303
 304         packet.type = DF_HEADER;
 305         packet.length = sizeof(struct datafeed_header);
 306         packet.payload = (unsigned char *) &header;
 307         header.feed_version = 1;
 308         gettimeofday(&header.starttime, NULL);
 309         header.samplerate = alsa->cur_rate;
 310         header.num_analog_probes = NUM_PROBES;
 311         header.num_logic_probes = 0;
 312         header.protocol_id = PROTO_RAW;
 313         session_bus(session_device_id, &packet);
 314         free(ufds);
 315
 316         return SIGROK_OK;
 317 }
 318
 319 static void hw_stop_acquisition(int device_index, gpointer session_device_id)
 320 {
 321         /* Avoid compiler warnings. */
 322         device_index = device_index;
 323         session_device_id = session_device_id;
 324 }
 325
 326 struct device_plugin alsa_plugin_info = {
 327         "alsa",
 328         1,
 329         hw_init,
 330         hw_cleanup,
 331         hw_opendev,
 332         hw_closedev,
 333         hw_get_device_info,
 334         hw_get_status,
 335         hw_get_capabilities,
 336         hw_set_configuration,
 337         hw_start_acquisition,
 338         hw_stop_acquisition,
 339 };