hardware/colead-slm/api.c

   1 /*
   2  * This file is part of the libsigrok project.
   3  *
   4  * Copyright (C) 2012 Bert Vermeulen <bert@biot.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 3 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, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include <glib.h>
  21 #include "libsigrok.h"
  22 #include "libsigrok-internal.h"
  23 #include "protocol.h"
  24 #include <sys/types.h>
  25 #include <sys/stat.h>
  26 #include <fcntl.h>
  27 #include <errno.h>
  28 #include <string.h>
  29
  30 /* The Colead SL-5868P uses this. */
  31 #define SERIALCOMM "2400/8n1"
  32
  33 static const int32_t hwopts[] = {
  34         SR_CONF_CONN,
  35         SR_CONF_SERIALCOMM,
  36 };
  37
  38 static const int32_t hwcaps[] = {
  39         SR_CONF_SOUNDLEVELMETER,
  40         SR_CONF_LIMIT_SAMPLES,
  41         SR_CONF_LIMIT_MSEC,
  42         SR_CONF_CONTINUOUS,
  43 };
  44
  45 SR_PRIV struct sr_dev_driver colead_slm_driver_info;
  46 static struct sr_dev_driver *di = &colead_slm_driver_info;
  47
  48 /* Properly close and free all devices. */
  49 static int clear_instances(void)
  50 {
  51         struct sr_dev_inst *sdi;
  52         struct drv_context *drvc;
  53         struct dev_context *devc;
  54         GSList *l;
  55
  56         if (!(drvc = di->priv))
  57                 return SR_OK;
  58
  59         for (l = drvc->instances; l; l = l->next) {
  60                 if (!(sdi = l->data))
  61                         continue;
  62                 if (!(devc = sdi->priv))
  63                         continue;
  64                 sr_serial_dev_inst_free(devc->serial);
  65                 sr_dev_inst_free(sdi);
  66         }
  67         g_slist_free(drvc->instances);
  68         drvc->instances = NULL;
  69
  70         return SR_OK;
  71 }
  72
  73 static int hw_init(struct sr_context *sr_ctx)
  74 {
  75         return std_hw_init(sr_ctx, di, DRIVER_LOG_DOMAIN);
  76 }
  77
  78 static GSList *hw_scan(GSList *options)
  79 {
  80         struct drv_context *drvc;
  81         struct dev_context *devc;
  82         struct sr_dev_inst *sdi;
  83         struct sr_config *src;
  84         struct sr_probe *probe;
  85         GSList *devices, *l;
  86         const char *conn, *serialcomm;
  87
  88         drvc = di->priv;
  89         drvc->instances = NULL;
  90
  91         devices = NULL;
  92
  93         conn = serialcomm = NULL;
  94         for (l = options; l; l = l->next) {
  95                 src = l->data;
  96                 switch (src->key) {
  97                 case SR_CONF_CONN:
  98                         conn = g_variant_get_string(src->data, NULL);
  99                         break;
 100                 case SR_CONF_SERIALCOMM:
 101                         serialcomm = g_variant_get_string(src->data, NULL);
 102                         break;
 103                 }
 104         }
 105         if (!conn)
 106                 return NULL;
 107         if (!serialcomm)
 108                 serialcomm = SERIALCOMM;
 109
 110         if (!(sdi = sr_dev_inst_new(0, SR_ST_INACTIVE, "Colead",
 111                         "SL-5868P", NULL)))
 112                 return NULL;
 113
 114         if (!(devc = g_try_malloc0(sizeof(struct dev_context)))) {
 115                 sr_dbg("Device context malloc failed.");
 116                 return NULL;
 117         }
 118
 119         if (!(devc->serial = sr_serial_dev_inst_new(conn, serialcomm)))
 120                 return NULL;
 121
 122         sdi->priv = devc;
 123         sdi->driver = di;
 124         if (!(probe = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "P1")))
 125                 return NULL;
 126         sdi->probes = g_slist_append(sdi->probes, probe);
 127         drvc->instances = g_slist_append(drvc->instances, sdi);
 128         devices = g_slist_append(devices, sdi);
 129
 130         return devices;
 131 }
 132
 133 static GSList *hw_dev_list(void)
 134 {
 135         return ((struct drv_context *)(di->priv))->instances;
 136 }
 137
 138 static int hw_dev_open(struct sr_dev_inst *sdi)
 139 {
 140         struct dev_context *devc;
 141
 142         if (!(devc = sdi->priv)) {
 143                 sr_err("sdi->priv was NULL.");
 144                 return SR_ERR_BUG;
 145         }
 146
 147         if (serial_open(devc->serial, SERIAL_RDWR) != SR_OK)
 148                 return SR_ERR;
 149
 150         sdi->status = SR_ST_ACTIVE;
 151
 152         return SR_OK;
 153 }
 154
 155 static int hw_dev_close(struct sr_dev_inst *sdi)
 156 {
 157         struct dev_context *devc;
 158
 159         devc = sdi->priv;
 160
 161         if (devc->serial && devc->serial->fd != -1) {
 162                 serial_close(devc->serial);
 163                 sdi->status = SR_ST_INACTIVE;
 164         }
 165
 166         return SR_OK;
 167 }
 168
 169 static int hw_cleanup(void)
 170 {
 171         clear_instances();
 172
 173         return SR_OK;
 174 }
 175
 176 static int config_set(int id, GVariant *data, const struct sr_dev_inst *sdi)
 177 {
 178         struct dev_context *devc;
 179
 180         if (sdi->status != SR_ST_ACTIVE)
 181                 return SR_ERR;
 182
 183         if (!(devc = sdi->priv)) {
 184                 sr_err("sdi->priv was NULL.");
 185                 return SR_ERR_BUG;
 186         }
 187
 188         switch (id) {
 189         case SR_CONF_LIMIT_MSEC:
 190                 /* TODO: not yet implemented */
 191                 if (g_variant_get_uint64(data) == 0) {
 192                         sr_err("LIMIT_MSEC can't be 0.");
 193                         return SR_ERR;
 194                 }
 195                 devc->limit_msec = g_variant_get_uint64(data);;
 196                 sr_dbg("Setting time limit to %" PRIu64 "ms.",
 197                        devc->limit_msec);
 198                 break;
 199         case SR_CONF_LIMIT_SAMPLES:
 200                 devc->limit_samples = g_variant_get_uint64(data);
 201                 sr_dbg("Setting sample limit to %" PRIu64 ".",
 202                        devc->limit_samples);
 203                 break;
 204         default:
 205                 return SR_ERR_NA;
 206         }
 207
 208         return SR_OK;
 209 }
 210
 211 static int config_list(int key, GVariant **data, const struct sr_dev_inst *sdi)
 212 {
 213
 214         (void)sdi;
 215
 216         switch (key) {
 217         case SR_CONF_SCAN_OPTIONS:
 218                 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
 219                                 hwopts, ARRAY_SIZE(hwopts), sizeof(int32_t));
 220                 break;
 221         case SR_CONF_DEVICE_OPTIONS:
 222                 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
 223                                 hwcaps, ARRAY_SIZE(hwcaps), sizeof(int32_t));
 224                 break;
 225         default:
 226                 return SR_ERR_NA;
 227         }
 228
 229         return SR_OK;
 230 }
 231
 232 static int hw_dev_acquisition_start(const struct sr_dev_inst *sdi,
 233                                     void *cb_data)
 234 {
 235         struct dev_context *devc;
 236
 237         if (!(devc = sdi->priv)) {
 238                 sr_err("sdi->priv was NULL.");
 239                 return SR_ERR_BUG;
 240         }
 241
 242         devc->cb_data = cb_data;
 243
 244         /* Send header packet to the session bus. */
 245         std_session_send_df_header(cb_data, DRIVER_LOG_DOMAIN);
 246
 247         /* Poll every 150ms, or whenever some data comes in. */
 248         sr_source_add(devc->serial->fd, G_IO_IN, 150, colead_slm_receive_data,
 249                         (void *)sdi);
 250
 251         return SR_OK;
 252 }
 253
 254 static int hw_dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data)
 255 {
 256         return std_hw_dev_acquisition_stop_serial(sdi, cb_data, hw_dev_close,
 257                ((struct dev_context *)(sdi->priv))->serial, DRIVER_LOG_DOMAIN);
 258 }
 259
 260 SR_PRIV struct sr_dev_driver colead_slm_driver_info = {
 261         .name = "colead-slm",
 262         .longname = "Colead SLM",
 263         .api_version = 1,
 264         .init = hw_init,
 265         .cleanup = hw_cleanup,
 266         .scan = hw_scan,
 267         .dev_list = hw_dev_list,
 268         .dev_clear = clear_instances,
 269         .config_get = NULL,
 270         .config_set = config_set,
 271         .config_list = config_list,
 272         .dev_open = hw_dev_open,
 273         .dev_close = hw_dev_close,
 274         .dev_acquisition_start = hw_dev_acquisition_start,
 275         .dev_acquisition_stop = hw_dev_acquisition_stop,
 276         .priv = NULL,
 277 };