src/hardware/juntek-jds6600/api.c

   1 /*
   2  * This file is part of the libsigrok project.
   3  *
   4  * Copyright (C) 2023 Gerhard Sittig <gerhard.sittig@gmx.net>
   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 "config.h"
  21
  22 #include "protocol.h"
  23
  24 #define DFLT_SERIALCOMM "115200/8n1"
  25
  26 #define VENDOR_TEXT     "Juntek"
  27 #define MODEL_TEXT      "JDS6600"
  28
  29 static const uint32_t scanopts[] = {
  30         SR_CONF_CONN,
  31 };
  32
  33 static const uint32_t drvopts[] = {
  34         SR_CONF_SIGNAL_GENERATOR,
  35 };
  36
  37 static const uint32_t devopts[] = {
  38         SR_CONF_CONN | SR_CONF_GET,
  39         SR_CONF_ENABLED | SR_CONF_SET,
  40         SR_CONF_PHASE | SR_CONF_GET | SR_CONF_SET,
  41 };
  42
  43 static const uint32_t devopts_cg[] = {
  44         SR_CONF_ENABLED | SR_CONF_GET | SR_CONF_SET,
  45         SR_CONF_PATTERN_MODE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
  46         SR_CONF_OUTPUT_FREQUENCY | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
  47         SR_CONF_AMPLITUDE | SR_CONF_GET | SR_CONF_SET,
  48         SR_CONF_OFFSET | SR_CONF_GET | SR_CONF_SET,
  49         SR_CONF_DUTY_CYCLE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
  50 };
  51
  52 static GSList *scan(struct sr_dev_driver *di, GSList *options)
  53 {
  54         GSList *devices;
  55         const char *conn, *serialcomm;
  56         struct sr_dev_inst *sdi;
  57         struct dev_context *devc;
  58         struct sr_serial_dev_inst *ser;
  59         int ret;
  60         size_t ch_idx, idx, ch_nr;
  61         char cg_name[8];
  62         struct sr_channel_group *cg;
  63         struct sr_channel *ch;
  64
  65         devices = NULL;
  66
  67         conn = NULL;
  68         serialcomm = DFLT_SERIALCOMM;
  69         (void)sr_serial_extract_options(options, &conn, &serialcomm);
  70         if (!conn)
  71                 return devices;
  72
  73         ser = sr_serial_dev_inst_new(conn, serialcomm);
  74         if (!ser)
  75                 return devices;
  76         ret = serial_open(ser, SERIAL_RDWR);
  77         if (ret != SR_OK)
  78                 return devices;
  79
  80         sdi = g_malloc0(sizeof(*sdi));
  81         sdi->status = SR_ST_INACTIVE;
  82         sdi->inst_type = SR_INST_USB;
  83         sdi->conn = ser;
  84         sdi->connection_id = g_strdup(conn);
  85         devc = g_malloc0(sizeof(*devc));
  86         sdi->priv = devc;
  87
  88         ret = jds6600_identify(sdi);
  89         if (ret != SR_OK)
  90                 goto fail;
  91         ret = jds6600_setup_devc(sdi);
  92         if (ret != SR_OK)
  93                 goto fail;
  94         (void)serial_close(ser);
  95
  96         sdi->vendor = g_strdup(VENDOR_TEXT);
  97         sdi->model = g_strdup(MODEL_TEXT);
  98         if (devc->device.serial_number)
  99                 sdi->serial_num = g_strdup(devc->device.serial_number);
 100
 101         ch_idx = 0;
 102         for (idx = 0; idx < MAX_GEN_CHANNELS; idx++) {
 103                 ch_nr = idx + 1;
 104                 snprintf(cg_name, sizeof(cg_name), "CH%zu", ch_nr);
 105                 cg = sr_channel_group_new(sdi, cg_name, NULL);
 106                 (void)cg;
 107                 ch = sr_channel_new(sdi, ch_idx,
 108                         SR_CHANNEL_ANALOG, FALSE, cg_name);
 109                 cg->channels = g_slist_append(cg->channels, ch);
 110                 ch_idx++;
 111         }
 112
 113         devices = g_slist_append(devices, sdi);
 114         return std_scan_complete(di, devices);
 115
 116 fail:
 117         (void)serial_close(ser);
 118         sr_serial_dev_inst_free(ser);
 119         if (devc) {
 120                 g_free(devc->device.serial_number);
 121                 g_free(devc->waveforms.fw_codes);
 122                 g_free(devc->waveforms.names);
 123         }
 124         g_free(devc);
 125         sr_dev_inst_free(sdi);
 126
 127         return devices;
 128 }
 129
 130 static int config_get(uint32_t key, GVariant **data,
 131         const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
 132 {
 133         struct dev_context *devc;
 134         int ret;
 135         size_t cg_idx;
 136         struct devc_wave *waves;
 137         struct devc_chan *chan;
 138         double dvalue;
 139         const char *s;
 140
 141         devc = sdi ? sdi->priv : NULL;
 142         if (!cg) {
 143                 switch (key) {
 144                 case SR_CONF_CONN:
 145                         if (!sdi->connection_id)
 146                                 return SR_ERR_NA;
 147                         *data = g_variant_new_string(sdi->connection_id);
 148                         return SR_OK;
 149                 case SR_CONF_PHASE:
 150                         if (!devc)
 151                                 return SR_ERR_NA;
 152                         ret = jds6600_get_phase_chans(sdi);
 153                         if (ret != SR_OK)
 154                                 return SR_ERR_NA;
 155                         dvalue = devc->channels_phase;
 156                         *data = g_variant_new_double(dvalue);
 157                         return SR_OK;
 158                 default:
 159                         return SR_ERR_NA;
 160                 }
 161         }
 162
 163         if (!devc)
 164                 return SR_ERR_NA;
 165         ret = g_slist_index(sdi->channel_groups, cg);
 166         if (ret < 0)
 167                 return SR_ERR_NA;
 168         cg_idx = (size_t)ret;
 169         if (cg_idx >= ARRAY_SIZE(devc->channel_config))
 170                 return SR_ERR_NA;
 171         chan = &devc->channel_config[cg_idx];
 172
 173         switch (key) {
 174         case SR_CONF_ENABLED:
 175                 ret = jds6600_get_chans_enable(sdi);
 176                 if (ret != SR_OK)
 177                         return SR_ERR_NA;
 178                 *data = g_variant_new_boolean(chan->enabled);
 179                 return SR_OK;
 180         case SR_CONF_PATTERN_MODE:
 181                 ret = jds6600_get_waveform(sdi, cg_idx);
 182                 if (ret != SR_OK)
 183                         return SR_ERR_NA;
 184                 waves = &devc->waveforms;
 185                 s = waves->names[chan->waveform_index];
 186                 *data = g_variant_new_string(s);
 187                 return SR_OK;
 188         case SR_CONF_OUTPUT_FREQUENCY:
 189                 ret = jds6600_get_frequency(sdi, cg_idx);
 190                 if (ret != SR_OK)
 191                         return SR_ERR_NA;
 192                 dvalue = chan->output_frequency;
 193                 *data = g_variant_new_double(dvalue);
 194                 return SR_OK;
 195         case SR_CONF_AMPLITUDE:
 196                 ret = jds6600_get_amplitude(sdi, cg_idx);
 197                 if (ret != SR_OK)
 198                         return SR_ERR_NA;
 199                 dvalue = chan->amplitude;
 200                 *data = g_variant_new_double(dvalue);
 201                 return SR_OK;
 202         case SR_CONF_OFFSET:
 203                 ret = jds6600_get_offset(sdi, cg_idx);
 204                 if (ret != SR_OK)
 205                         return SR_ERR_NA;
 206                 dvalue = chan->offset;
 207                 *data = g_variant_new_double(dvalue);
 208                 return SR_OK;
 209         case SR_CONF_DUTY_CYCLE:
 210                 ret = jds6600_get_dutycycle(sdi, cg_idx);
 211                 if (ret != SR_OK)
 212                         return SR_ERR_NA;
 213                 dvalue = chan->dutycycle;
 214                 *data = g_variant_new_double(dvalue);
 215                 return SR_OK;
 216         default:
 217                 return SR_ERR_NA;
 218         }
 219 }
 220
 221 static int config_set(uint32_t key, GVariant *data,
 222         const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
 223 {
 224         struct dev_context *devc;
 225         struct devc_wave *waves;
 226         struct devc_chan *chan;
 227         size_t cg_idx;
 228         double dvalue;
 229         gboolean on;
 230         int ret, idx;
 231
 232         devc = sdi ? sdi->priv : NULL;
 233
 234         if (!cg) {
 235                 switch (key) {
 236                 case SR_CONF_ENABLED:
 237                         /* Enable/disable all channels at the same time. */
 238                         on = g_variant_get_boolean(data);
 239                         if (!devc)
 240                                 return SR_ERR_ARG;
 241                         cg_idx = devc->device.channel_count_gen;
 242                         while (cg_idx) {
 243                                 chan = &devc->channel_config[--cg_idx];
 244                                 chan->enabled = on;
 245                         }
 246                         ret = jds6600_set_chans_enable(sdi);
 247                         if (ret != SR_OK)
 248                                 return SR_ERR_NA;
 249                         return SR_OK;
 250                 case SR_CONF_PHASE:
 251                         if (!devc)
 252                                 return SR_ERR_ARG;
 253                         dvalue = g_variant_get_double(data);
 254                         devc->channels_phase = dvalue;
 255                         ret = jds6600_set_phase_chans(sdi);
 256                         if (ret != SR_OK)
 257                                 return SR_ERR_NA;
 258                         return SR_OK;
 259                 default:
 260                         return SR_ERR_NA;
 261                 }
 262         }
 263
 264         ret = g_slist_index(sdi->channel_groups, cg);
 265         if (ret < 0)
 266                 return SR_ERR_NA;
 267         cg_idx = (size_t)ret;
 268         if (cg_idx >= ARRAY_SIZE(devc->channel_config))
 269                 return SR_ERR_NA;
 270         chan = &devc->channel_config[cg_idx];
 271
 272         switch (key) {
 273         case SR_CONF_ENABLED:
 274                 on = g_variant_get_boolean(data);
 275                 chan->enabled = on;
 276                 ret = jds6600_set_chans_enable(sdi);
 277                 if (ret != SR_OK)
 278                         return SR_ERR_NA;
 279                 return SR_OK;
 280         case SR_CONF_PATTERN_MODE:
 281                 waves = &devc->waveforms;
 282                 idx = std_str_idx(data, waves->names, waves->names_count);
 283                 if (idx < 0)
 284                         return SR_ERR_NA;
 285                 if ((size_t)idx >= waves->names_count)
 286                         return SR_ERR_NA;
 287                 chan->waveform_index = idx;
 288                 chan->waveform_code = waves->fw_codes[chan->waveform_index];
 289                 ret = jds6600_set_waveform(sdi, cg_idx);
 290                 if (ret != SR_OK)
 291                         return SR_ERR_NA;
 292                 return SR_OK;
 293         case SR_CONF_OUTPUT_FREQUENCY:
 294                 dvalue = g_variant_get_double(data);
 295                 chan->output_frequency = dvalue;
 296                 ret = jds6600_set_frequency(sdi, cg_idx);
 297                 if (ret != SR_OK)
 298                         return SR_ERR_NA;
 299                 return SR_OK;
 300         case SR_CONF_AMPLITUDE:
 301                 dvalue = g_variant_get_double(data);
 302                 chan->amplitude = dvalue;
 303                 ret = jds6600_set_amplitude(sdi, cg_idx);
 304                 if (ret != SR_OK)
 305                         return SR_ERR_NA;
 306                 return SR_OK;
 307         case SR_CONF_OFFSET:
 308                 dvalue = g_variant_get_double(data);
 309                 chan->offset = dvalue;
 310                 ret = jds6600_set_offset(sdi, cg_idx);
 311                 if (ret != SR_OK)
 312                         return SR_ERR_NA;
 313                 return SR_OK;
 314         case SR_CONF_DUTY_CYCLE:
 315                 dvalue = g_variant_get_double(data);
 316                 chan->dutycycle = dvalue;
 317                 ret = jds6600_set_dutycycle(sdi, cg_idx);
 318                 if (ret != SR_OK)
 319                         return SR_ERR_NA;
 320                 return SR_OK;
 321         default:
 322                 return SR_ERR_NA;
 323         }
 324 }
 325
 326 static int config_list(uint32_t key, GVariant **data,
 327         const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
 328 {
 329         struct dev_context *devc;
 330         struct devc_wave *waves;
 331         double fspec[3];
 332
 333         if (!cg) {
 334                 switch (key) {
 335                 case SR_CONF_SCAN_OPTIONS:
 336                 case SR_CONF_DEVICE_OPTIONS:
 337                         return STD_CONFIG_LIST(key, data, sdi, cg,
 338                                 scanopts, drvopts, devopts);
 339                 default:
 340                         return SR_ERR_NA;
 341                 }
 342         }
 343
 344         if (!sdi)
 345                 return SR_ERR_NA;
 346         devc = sdi->priv;
 347         if (!devc)
 348                 return SR_ERR_NA;
 349         switch (key) {
 350         case SR_CONF_DEVICE_OPTIONS:
 351                 *data =std_gvar_array_u32(ARRAY_AND_SIZE(devopts_cg));
 352                 return SR_OK;
 353         case SR_CONF_PATTERN_MODE:
 354                 waves = &devc->waveforms;
 355                 *data = std_gvar_array_str(waves->names, waves->names_count);
 356                 return SR_OK;
 357         case SR_CONF_OUTPUT_FREQUENCY:
 358                 /* Announce range as tupe of min, max, step. */
 359                 fspec[0] = 0.01;
 360                 fspec[1] = devc->device.max_output_frequency;
 361                 fspec[2] = 0.01;
 362                 *data = std_gvar_min_max_step_array(fspec);
 363                 return SR_OK;
 364         case SR_CONF_DUTY_CYCLE:
 365                 /* Announce range as tupe of min, max, step. */
 366                 fspec[0] = 0.0;
 367                 fspec[1] = 1.0;
 368                 fspec[2] = 0.001;
 369                 *data = std_gvar_min_max_step_array(fspec);
 370                 return SR_OK;
 371         default:
 372                 return SR_ERR_NA;
 373         }
 374 }
 375
 376 static void clear_helper(struct dev_context *devc)
 377 {
 378         struct devc_wave *waves;
 379
 380         if (!devc)
 381                 return;
 382
 383         g_free(devc->device.serial_number);
 384         waves = &devc->waveforms;
 385         while (waves->names_count)
 386                 g_free((char *)waves->names[--waves->names_count]);
 387         g_free(waves->names);
 388         g_free(waves->fw_codes);
 389         if (devc->quick_req)
 390                 g_string_free(devc->quick_req, TRUE);
 391 }
 392
 393 static int dev_clear(const struct sr_dev_driver *driver)
 394 {
 395         return std_dev_clear_with_callback(driver,
 396                 (std_dev_clear_callback)clear_helper);
 397 }
 398
 399 static struct sr_dev_driver juntek_jds6600_driver_info = {
 400         .name = "juntek-jds6600",
 401         .longname = "JUNTEK JDS6600",
 402         .api_version = 1,
 403         .init = std_init,
 404         .cleanup = std_cleanup,
 405         .scan = scan,
 406         .dev_list = std_dev_list,
 407         .dev_clear = dev_clear,
 408         .config_get = config_get,
 409         .config_set = config_set,
 410         .config_list = config_list,
 411         .dev_open = std_serial_dev_open,
 412         .dev_close = std_serial_dev_close,
 413         .dev_acquisition_start = std_dummy_dev_acquisition_start,
 414         .dev_acquisition_stop = std_dummy_dev_acquisition_stop,
 415         .context = NULL,
 416 };
 417 SR_REGISTER_DEV_DRIVER(juntek_jds6600_driver_info);