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 static int receive_data(int fd, int revents, void *user_data)
 203 {
 204         struct sigrok_device_instance *sdi = user_data;
 205         struct alsa *alsa = sdi->priv;
 206         struct datafeed_packet packet;
 207         struct analog_sample *sample;
 208         unsigned int sample_size = sizeof(struct analog_sample) +
 209                 (NUM_PROBES * sizeof(struct analog_probe));
 210         char *outb;
 211         char inb[4096];
 212         int i, x, count;
 213
 214         do {
 215                 memset(inb, 0, sizeof(inb));
 216                 count = snd_pcm_readi(alsa->capture_handle, inb,
 217                         MIN(4096/4, alsa->limit_samples));
 218                 if (count < 1) {
 219                         g_warning("Failed to read samples");
 220                         return FALSE;
 221                 }
 222
 223                 outb = malloc(sample_size * count);
 224                 if (!outb)
 225                         return FALSE;
 226
 227                 for (i = 0; i < count; i++) {
 228                         sample = (struct analog_sample *)
 229                                                 (outb + (i * sample_size));
 230                         sample->num_probes = NUM_PROBES;
 231
 232                         for (x = 0; x < NUM_PROBES; x++) {
 233                                 sample->probes[x].val =
 234                                         *(uint16_t *) (inb + (i * 4) + (x * 2));
 235                                 sample->probes[x].val &= ((1 << 16) - 1);
 236                                 sample->probes[x].res = 16;
 237                         }
 238                 }
 239
 240                 packet.type = DF_ANALOG;
 241                 packet.length = count * sample_size;
 242                 packet.unitsize = sample_size;
 243                 packet.payload = outb;
 244                 session_bus(user_data, &packet);
 245                 free(outb);
 246                 alsa->limit_samples -= count;
 247
 248         } while (alsa->limit_samples > 0);
 249
 250         packet.type = DF_END;
 251         session_bus(user_data, &packet);
 252
 253         return TRUE;
 254 }
 255
 256 static int hw_start_acquisition(int device_index, gpointer session_device_id)
 257 {
 258         struct sigrok_device_instance *sdi;
 259         struct alsa *alsa;
 260         struct datafeed_packet packet;
 261         struct datafeed_header header;
 262         struct pollfd *ufds;
 263         int count;
 264         int err;
 265
 266         if (!(sdi = get_sigrok_device_instance(device_instances, device_index)))
 267                 return SIGROK_ERR;
 268         alsa = sdi->priv;
 269
 270         err = snd_pcm_hw_params_set_access(alsa->capture_handle,
 271                         alsa->hw_params, SND_PCM_ACCESS_RW_INTERLEAVED);
 272         if (err < 0) {
 273                 g_warning("cannot set access type (%s)", snd_strerror(err));
 274                 return SIGROK_ERR;
 275         }
 276
 277         /* FIXME: Hardcoded for 16bits */
 278         err = snd_pcm_hw_params_set_format(alsa->capture_handle,
 279                         alsa->hw_params, SND_PCM_FORMAT_S16_LE);
 280         if (err < 0) {
 281                 g_warning("cannot set sample format (%s)", snd_strerror(err));
 282                 return SIGROK_ERR;
 283         }
 284
 285         err = snd_pcm_hw_params_set_rate_near(alsa->capture_handle,
 286                         alsa->hw_params, (unsigned int *) &alsa->cur_rate, 0);
 287         if (err < 0) {
 288                 g_warning("cannot set sample rate (%s)", snd_strerror(err));
 289                 return SIGROK_ERR;
 290         }
 291
 292         err = snd_pcm_hw_params_set_channels(alsa->capture_handle,
 293                         alsa->hw_params, NUM_PROBES);
 294         if (err < 0) {
 295                 g_warning("cannot set channel count (%s)", snd_strerror(err));
 296                 return SIGROK_ERR;
 297         }
 298
 299         err = snd_pcm_hw_params(alsa->capture_handle, alsa->hw_params);
 300         if (err < 0) {
 301                 g_warning("cannot set parameters (%s)", snd_strerror(err));
 302                 return SIGROK_ERR;
 303         }
 304
 305         err = snd_pcm_prepare(alsa->capture_handle);
 306         if (err < 0) {
 307                 g_warning("cannot prepare audio interface for use (%s)",
 308                                 snd_strerror(err));
 309                 return SIGROK_ERR;
 310         }
 311
 312         count = snd_pcm_poll_descriptors_count(alsa->capture_handle);
 313         if (count < 1) {
 314                 g_warning("Unable to obtain poll descriptors count");
 315                 return SIGROK_ERR;
 316         }
 317
 318         ufds = malloc(count * sizeof(struct pollfd));
 319         if (!ufds)
 320                 return SIGROK_ERR_MALLOC;
 321
 322         err = snd_pcm_poll_descriptors(alsa->capture_handle, ufds, count);
 323         if (err < 0) {
 324                 g_warning("Unable to obtain poll descriptors (%s)",
 325                                 snd_strerror(err));
 326                 free(ufds);
 327                 return SIGROK_ERR;
 328         }
 329
 330         alsa->session_id = session_device_id;
 331         source_add(ufds[0].fd, ufds[0].events, 10, receive_data, sdi);
 332
 333         packet.type = DF_HEADER;
 334         packet.length = sizeof(struct datafeed_header);
 335         packet.payload = (unsigned char *) &header;
 336         header.feed_version = 1;
 337         gettimeofday(&header.starttime, NULL);
 338         header.samplerate = alsa->cur_rate;
 339         header.num_analog_probes = NUM_PROBES;
 340         header.num_logic_probes = 0;
 341         header.protocol_id = PROTO_RAW;
 342         session_bus(session_device_id, &packet);
 343         free(ufds);
 344
 345         return SIGROK_OK;
 346 }
 347
 348 static void hw_stop_acquisition(int device_index, gpointer session_device_id)
 349 {
 350         /* Avoid compiler warnings. */
 351         device_index = device_index;
 352         session_device_id = session_device_id;
 353 }
 354
 355 struct device_plugin alsa_plugin_info = {
 356         "alsa",
 357         1,
 358         hw_init,
 359         hw_cleanup,
 360         hw_opendev,
 361         hw_closedev,
 362         hw_get_device_info,
 363         hw_get_status,
 364         hw_get_capabilities,
 365         hw_set_configuration,
 366         hw_start_acquisition,
 367         hw_stop_acquisition,
 368 };