src/hardware/itech-it8500/api.c

   1 /*
   2  * This file is part of the libsigrok project.
   3  *
   4  * Copyright (C) 2020 Timo Kokkonen <tjko@iki.fi>
   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 #include <string.h>
  22 #include "protocol.h"
  23
  24 #define MIN_SAMPLE_RATE SR_HZ(1)
  25 #define MAX_SAMPLE_RATE SR_HZ(60)
  26 #define DEFAULT_SAMPLE_RATE SR_HZ(10)
  27
  28 static const uint32_t scanopts[] = {
  29         SR_CONF_CONN,
  30         SR_CONF_SERIALCOMM,
  31 };
  32
  33 static const uint32_t drvopts[] = {
  34         SR_CONF_ELECTRONIC_LOAD,
  35 };
  36
  37 static const uint32_t devopts[] = {
  38         SR_CONF_CONTINUOUS,
  39         SR_CONF_LIMIT_SAMPLES | SR_CONF_GET | SR_CONF_SET,
  40         SR_CONF_LIMIT_MSEC | SR_CONF_GET | SR_CONF_SET,
  41         SR_CONF_SAMPLERATE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
  42 };
  43
  44 static const uint32_t devopts_cg[] = {
  45         SR_CONF_ENABLED | SR_CONF_GET | SR_CONF_SET,
  46         SR_CONF_REGULATION | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
  47         SR_CONF_VOLTAGE | SR_CONF_GET,
  48         SR_CONF_VOLTAGE_TARGET | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
  49         SR_CONF_CURRENT | SR_CONF_GET,
  50         SR_CONF_CURRENT_LIMIT | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
  51         SR_CONF_POWER | SR_CONF_GET,
  52         SR_CONF_POWER_TARGET | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
  53         SR_CONF_RESISTANCE_TARGET | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
  54         SR_CONF_OVER_VOLTAGE_PROTECTION_ENABLED | SR_CONF_GET,
  55         SR_CONF_OVER_VOLTAGE_PROTECTION_ACTIVE | SR_CONF_GET,
  56         SR_CONF_OVER_VOLTAGE_PROTECTION_THRESHOLD | SR_CONF_GET | SR_CONF_SET,
  57         SR_CONF_OVER_CURRENT_PROTECTION_ENABLED | SR_CONF_GET,
  58         SR_CONF_OVER_CURRENT_PROTECTION_ACTIVE | SR_CONF_GET,
  59         SR_CONF_OVER_CURRENT_PROTECTION_THRESHOLD | SR_CONF_GET | SR_CONF_SET,
  60         SR_CONF_UNDER_VOLTAGE_CONDITION | SR_CONF_GET,
  61         SR_CONF_UNDER_VOLTAGE_CONDITION_ACTIVE | SR_CONF_GET,
  62         SR_CONF_UNDER_VOLTAGE_CONDITION_THRESHOLD | SR_CONF_GET | SR_CONF_SET,
  63         SR_CONF_OVER_TEMPERATURE_PROTECTION | SR_CONF_GET,
  64         SR_CONF_OVER_TEMPERATURE_PROTECTION_ACTIVE | SR_CONF_GET,
  65 };
  66
  67 static const uint64_t samplerates[] = {
  68         SR_HZ(1),
  69         SR_HZ(2),
  70         SR_HZ(5),
  71         SR_HZ(10),
  72         SR_HZ(15),
  73         SR_HZ(20),
  74         SR_HZ(30),
  75         SR_HZ(40),
  76         SR_HZ(50),
  77         SR_HZ(60),
  78 };
  79
  80 static const char *default_serial_parameters[] = {
  81         "9600/8n1", /* Factory default. */
  82         "38400/8n1",
  83         "19200/8n1",
  84         "4800/8n1",
  85         NULL,
  86 };
  87
  88 static struct sr_dev_driver itech_it8500_driver_info;
  89
  90 static GSList *scan(struct sr_dev_driver *di, GSList *options)
  91 {
  92         struct sr_dev_inst *sdi;
  93         struct sr_config *conf;
  94         struct sr_serial_dev_inst *serial;
  95         struct sr_channel_group *cg;
  96         struct sr_channel *ch;
  97         struct dev_context *devc;
  98         const char *custom_serial_parameters[2];
  99         const char **serial_parameters;
 100         const char *conn, *serialcomm;
 101         GSList *l;
 102         struct itech_it8500_cmd_packet *cmd, *response;
 103         uint8_t fw_major, fw_minor;
 104         const uint8_t *p;
 105         char *unit_model, *unit_serial, *unit_barcode;
 106         double max_i, max_v, min_v, max_p, max_r, min_r;
 107         uint64_t max_samplerate;
 108
 109         size_t u, i;
 110         int ret;
 111
 112         cmd = g_malloc0(sizeof(*cmd));
 113         devc = g_malloc0(sizeof(*devc));
 114         sdi = g_malloc0(sizeof(*sdi));
 115         if (!cmd || !devc || !sdi)
 116                 return NULL;
 117
 118         serial = NULL;
 119         response = NULL;
 120         unit_model = NULL;
 121         unit_serial = NULL;
 122
 123         /*
 124          * Use a list of typical parameters for serial communication by
 125          * default. Prefer user specified parameters when available.
 126          * Lack of a user specified serial port is fatal.
 127          */
 128         conn = NULL;
 129         serialcomm = NULL;
 130         serial_parameters = default_serial_parameters;
 131         for (l = options; l; l = l->next) {
 132                 conf = l->data;
 133                 switch (conf->key) {
 134                 case SR_CONF_CONN:
 135                         conn = g_variant_get_string(conf->data, NULL);
 136                         break;
 137                 case SR_CONF_SERIALCOMM:
 138                         serialcomm = g_variant_get_string(conf->data, NULL);
 139                         custom_serial_parameters[0] = serialcomm;
 140                         custom_serial_parameters[1] = NULL;
 141                         serial_parameters = custom_serial_parameters;
 142                         break;
 143                 }
 144         }
 145         if (!conn)
 146                 goto error;
 147
 148         /*
 149          * Try different serial parameters in the list
 150          * until we get a response (or none at all).
 151          */
 152         sr_info("Probing serial port: %s", conn);
 153         for (i = 0; (serialcomm = serial_parameters[i]); i++) {
 154                 serial = sr_serial_dev_inst_new(conn, serialcomm);
 155                 if (serial_open(serial, SERIAL_RDWR) != SR_OK)
 156                         goto error;
 157                 serial_flush(serial);
 158
 159                 cmd->address = 0xff; /* Use "broadcast" address. */
 160                 cmd->command = CMD_GET_MODEL_INFO;
 161                 if (itech_it8500_send_cmd(serial, cmd, &response) == SR_OK)
 162                         break;
 163
 164                 serial_close(serial);
 165                 sr_serial_dev_inst_free(serial);
 166                 serial = NULL;
 167         }
 168         if (!serialcomm)
 169                 goto error;
 170
 171         /*
 172          * The "dense" response string consists of several fields. Grab
 173          * integer data before putting terminators in their place to
 174          * grab text strings afterwards. Order is important here.
 175          */
 176         devc->address = response->address;
 177         fw_major = response->data[6];
 178         fw_minor = response->data[5];
 179         response->data[5] = 0;
 180         unit_model = g_strdup((const char *)&response->data[0]);
 181         response->data[17] = 0;
 182         unit_serial = g_strdup((const char *)&response->data[7]);
 183         sr_info("Model name: %s (v%x.%02x)", unit_model, fw_major, fw_minor);
 184         sr_info("Address: %d", devc->address);
 185         sr_info("Serial number: %s", unit_serial);
 186
 187         sdi->status = SR_ST_INACTIVE;
 188         sdi->conn = serial;
 189         sdi->inst_type = SR_INST_SERIAL;
 190         sdi->driver = &itech_it8500_driver_info;
 191         sdi->priv = devc;
 192         g_mutex_init(&devc->mutex);
 193
 194         /*
 195          * Calculate maxium "safe" sample rate based on serial connection
 196          * speed / bitrate.
 197          */
 198         max_samplerate = serial->comm_params.bit_rate * 15 / 9600;
 199         if (max_samplerate < 15)
 200                 max_samplerate = 10;
 201         if (max_samplerate > MAX_SAMPLE_RATE)
 202                 max_samplerate = MAX_SAMPLE_RATE;
 203         devc->max_sample_rate_idx = 0;
 204         for (u = 0; u < ARRAY_SIZE(samplerates); u++) {
 205                 if (samplerates[u] > max_samplerate)
 206                         break;
 207                 devc->max_sample_rate_idx = u;
 208         }
 209         devc->sample_rate = DEFAULT_SAMPLE_RATE;
 210
 211         /*
 212          * Get full serial number (barcode).
 213          */
 214         cmd->address = devc->address;
 215         cmd->command = CMD_GET_BARCODE_INFO;
 216         if (itech_it8500_send_cmd(serial, cmd, &response) == SR_OK) {
 217                 unit_barcode = g_malloc0(IT8500_DATA_LEN + 1);
 218                 memcpy(unit_barcode, response->data, IT8500_DATA_LEN);
 219                 sr_info("Barcode: %s", response->data);
 220                 g_free(unit_barcode);
 221         }
 222
 223         /*
 224          * Query unit capabilities.
 225          */
 226         cmd->command = CMD_GET_LOAD_LIMITS;
 227         if (itech_it8500_send_cmd(serial, cmd, &response) != SR_OK)
 228                 goto error;
 229         p = response->data;
 230         max_i = read_u32le_inc(&p) / 10000.0;
 231         max_v = read_u32le_inc(&p) / 1000.0;
 232         min_v = read_u32le_inc(&p) / 1000.0;
 233         max_p = read_u32le_inc(&p) / 1000.0;
 234         max_r = read_u32le_inc(&p) / 1000.0;
 235         min_r = read_u16le_inc(&p) / 1000.0;
 236         sr_info("Max current: %.0f A", max_i);
 237         sr_info("Max power: %.0f W", max_p);
 238         sr_info("Voltage range: %.1f - %.1f V", min_v, max_v);
 239         sr_info("Resistance range: %.2f - %.2f Ohm", min_r, max_r);
 240
 241         /*
 242          * Get current status of the unit.
 243          */
 244         if ((ret = itech_it8500_get_status(sdi)) != SR_OK) {
 245                 sr_err("Failed to get unit status: %d", ret);
 246                 goto error;
 247         }
 248         sr_info("Mode: %s", itech_it8500_mode_to_string(devc->mode));
 249         sr_info("State: %s", devc->load_on ? "ON" : "OFF");
 250         sr_info("Default sample rate: %" PRIu64 " Hz", devc->sample_rate);
 251         sr_info("Maximum sample rate: %" PRIu64 " Hz",
 252                 samplerates[devc->max_sample_rate_idx]);
 253
 254         /*
 255          * Populate data structures.
 256          */
 257
 258         devc->fw_ver_major = fw_major;
 259         devc->fw_ver_minor = fw_minor;
 260         snprintf(devc->model, sizeof(devc->model), "%s", unit_model);
 261         devc->max_current = max_i;
 262         devc->min_voltage = min_v;
 263         devc->max_voltage = max_v;
 264         devc->max_power = max_p;
 265         devc->min_resistance = min_r;
 266         devc->max_resistance = max_r;
 267
 268         sdi->vendor = g_strdup("ITECH");
 269         sdi->model = unit_model;
 270         sdi->version = g_strdup_printf("%x.%02x", fw_major, fw_minor);
 271         sdi->serial_num = unit_serial;
 272
 273         cg = g_malloc0(sizeof(*cg));
 274         cg->name = g_strdup("1");
 275         sdi->channel_groups = g_slist_append(sdi->channel_groups, cg);
 276         ch = sr_channel_new(sdi, 0, SR_CHANNEL_ANALOG, TRUE, "V1");
 277         cg->channels = g_slist_append(cg->channels, ch);
 278         ch = sr_channel_new(sdi, 1, SR_CHANNEL_ANALOG, TRUE, "I1");
 279         cg->channels = g_slist_append(cg->channels, ch);
 280         ch = sr_channel_new(sdi, 2, SR_CHANNEL_ANALOG, TRUE, "P1");
 281         cg->channels = g_slist_append(cg->channels, ch);
 282
 283         g_free(cmd);
 284         g_free(response);
 285         serial_close(serial);
 286
 287         return std_scan_complete(di, g_slist_append(NULL, sdi));
 288
 289 error:
 290         g_free(cmd);
 291         g_free(devc);
 292         g_free(sdi);
 293         g_free(response);
 294         g_free(unit_model);
 295         g_free(unit_serial);
 296         if (serial) {
 297                 serial_close(serial);
 298                 sr_serial_dev_inst_free(serial);
 299         }
 300
 301         return NULL;
 302 }
 303
 304 static int config_get(uint32_t key, GVariant **data,
 305                 const struct sr_dev_inst *sdi,
 306                 const struct sr_channel_group *cg)
 307 {
 308         struct dev_context *devc;
 309         const struct sr_key_info *kinfo;
 310         const char *mode;
 311         int ret, ival;
 312         gboolean bval;
 313
 314         (void)cg;
 315
 316         if (!data || !sdi)
 317                 return SR_ERR_ARG;
 318
 319         devc = sdi->priv;
 320         kinfo = sr_key_info_get(SR_KEY_CONFIG, key);
 321         ret = SR_OK;
 322
 323         switch (key) {
 324         case SR_CONF_LIMIT_SAMPLES:
 325         case SR_CONF_LIMIT_MSEC:
 326                 ret = sr_sw_limits_config_get(&devc->limits, key, data);
 327                 break;
 328         case SR_CONF_SAMPLERATE:
 329                 *data = g_variant_new_uint64(devc->sample_rate);
 330                 break;
 331         case SR_CONF_ENABLED:
 332                 ret = itech_it8500_get_status(sdi);
 333                 if (ret == SR_OK)
 334                         *data = g_variant_new_boolean(devc->load_on);
 335                 break;
 336         case SR_CONF_REGULATION:
 337                 ret = itech_it8500_get_status(sdi);
 338                 if (ret == SR_OK) {
 339                         mode = itech_it8500_mode_to_string(devc->mode);
 340                         *data = g_variant_new_string(mode);
 341                 }
 342                 break;
 343         case SR_CONF_VOLTAGE:
 344                 ret = itech_it8500_get_status(sdi);
 345                 if (ret == SR_OK)
 346                         *data = g_variant_new_double(devc->voltage);
 347                 break;
 348         case SR_CONF_VOLTAGE_TARGET:
 349                 ret = itech_it8500_get_int(sdi, CMD_GET_CV_VOLTAGE, &ival);
 350                 if (ret == SR_OK)
 351                         *data = g_variant_new_double((double)ival / 1000.0);
 352                 break;
 353         case SR_CONF_CURRENT:
 354                 ret = itech_it8500_get_status(sdi);
 355                 if (ret == SR_OK)
 356                         *data = g_variant_new_double(devc->current);
 357                 break;
 358         case SR_CONF_CURRENT_LIMIT:
 359                 ret = itech_it8500_get_int(sdi, CMD_GET_CC_CURRENT, &ival);
 360                 if (ret == SR_OK)
 361                         *data = g_variant_new_double((double)ival / 10000.0);
 362                 break;
 363         case SR_CONF_POWER:
 364                 ret = itech_it8500_get_status(sdi);
 365                 if (ret == SR_OK)
 366                         *data = g_variant_new_double(devc->power);
 367                 break;
 368         case SR_CONF_POWER_TARGET:
 369                 ret = itech_it8500_get_int(sdi, CMD_GET_CW_POWER, &ival);
 370                 if (ret == SR_OK)
 371                         *data = g_variant_new_double((double)ival / 1000.0);
 372                 break;
 373         case SR_CONF_RESISTANCE_TARGET:
 374                 ret = itech_it8500_get_int(sdi, CMD_GET_CR_RESISTANCE, &ival);
 375                 if (ret == SR_OK)
 376                         *data = g_variant_new_double((double)ival / 1000.0);
 377                 break;
 378         case SR_CONF_OVER_VOLTAGE_PROTECTION_ENABLED:
 379                 *data = g_variant_new_boolean(TRUE);
 380                 break;
 381         case SR_CONF_OVER_VOLTAGE_PROTECTION_ACTIVE:
 382                 ret = itech_it8500_get_status(sdi);
 383                 if (ret == SR_OK) {
 384                         bval = devc->demand_state & DS_OV_FLAG;
 385                         *data = g_variant_new_boolean(bval);
 386                 }
 387                 break;
 388         case SR_CONF_OVER_VOLTAGE_PROTECTION_THRESHOLD:
 389                 ret = itech_it8500_get_int(sdi, CMD_GET_MAX_VOLTAGE, &ival);
 390                 if (ret == SR_OK)
 391                         *data = g_variant_new_double((double)ival / 1000.0);
 392                 break;
 393         case SR_CONF_OVER_CURRENT_PROTECTION_ENABLED:
 394                 *data = g_variant_new_boolean(TRUE);
 395                 break;
 396         case SR_CONF_OVER_CURRENT_PROTECTION_ACTIVE:
 397                 ret = itech_it8500_get_status(sdi);
 398                 if (ret == SR_OK) {
 399                         bval = devc->demand_state & DS_OC_FLAG;
 400                         *data = g_variant_new_boolean(bval);
 401                 }
 402                 break;
 403         case SR_CONF_OVER_CURRENT_PROTECTION_THRESHOLD:
 404                 ret = itech_it8500_get_int(sdi, CMD_GET_MAX_CURRENT, &ival);
 405                 if (ret == SR_OK)
 406                         *data = g_variant_new_double((double)ival / 10000.0);
 407                 break;
 408         case SR_CONF_OVER_TEMPERATURE_PROTECTION:
 409                 *data = g_variant_new_boolean(TRUE);
 410                 break;
 411         case SR_CONF_OVER_TEMPERATURE_PROTECTION_ACTIVE:
 412                 ret = itech_it8500_get_status(sdi);
 413                 if (ret == SR_OK) {
 414                         bval = devc->demand_state & DS_OT_FLAG;
 415                         *data = g_variant_new_boolean(bval);
 416                 }
 417                 break;
 418         /* Hardware doesn't support under voltage reporting. */
 419         case SR_CONF_UNDER_VOLTAGE_CONDITION:
 420         case SR_CONF_UNDER_VOLTAGE_CONDITION_ACTIVE:
 421                 *data = g_variant_new_boolean(FALSE);
 422                 break;
 423         case SR_CONF_UNDER_VOLTAGE_CONDITION_THRESHOLD:
 424                 *data = g_variant_new_double(0.0);
 425                 break;
 426         default:
 427                 sr_dbg("%s: Unsupported key: %u (%s)", __func__, key,
 428                         kinfo ? kinfo->name : "unknown");
 429                 ret = SR_ERR_NA;
 430         }
 431
 432         return ret;
 433 }
 434
 435 static int config_set(uint32_t key, GVariant *data,
 436                 const struct sr_dev_inst *sdi,
 437                 const struct sr_channel_group *cg)
 438 {
 439         struct dev_context *devc;
 440         struct itech_it8500_cmd_packet *cmd, *response;
 441         const struct sr_key_info *kinfo;
 442         enum itech_it8500_modes mode;
 443         int ret, ivalue;
 444         uint64_t new_sr;
 445         const char *s;
 446
 447         (void)cg;
 448
 449         if (!data || !sdi)
 450                 return SR_ERR_ARG;
 451
 452         cmd = g_malloc0(sizeof(*cmd));
 453         if (!cmd)
 454                 return SR_ERR_MALLOC;
 455
 456         devc = sdi->priv;
 457         response = NULL;
 458         ret = SR_OK;
 459
 460         kinfo = sr_key_info_get(SR_KEY_CONFIG, key);
 461
 462         switch (key) {
 463         case SR_CONF_LIMIT_MSEC:
 464         case SR_CONF_LIMIT_SAMPLES:
 465                 ret = sr_sw_limits_config_set(&devc->limits, key, data);
 466                 goto done;
 467         case SR_CONF_SAMPLERATE:
 468                 new_sr = g_variant_get_uint64(data);
 469                 if (new_sr < MIN_SAMPLE_RATE ||
 470                     new_sr > samplerates[devc->max_sample_rate_idx]) {
 471                         ret = SR_ERR_SAMPLERATE;
 472                         goto done;
 473                 }
 474                 devc->sample_rate = new_sr;
 475                 goto done;
 476         case SR_CONF_ENABLED:
 477                 cmd->command = CMD_LOAD_ON_OFF;
 478                 cmd->data[0] = g_variant_get_boolean(data);
 479                 break;
 480         case SR_CONF_REGULATION:
 481                 cmd->command = CMD_SET_MODE;
 482                 s = g_variant_get_string(data, NULL);
 483                 if (itech_it8500_string_to_mode(s, &mode) != SR_OK) {
 484                         ret = SR_ERR_ARG;
 485                         goto done;
 486                 }
 487                 cmd->data[0] = mode;
 488                 break;
 489         case SR_CONF_VOLTAGE_TARGET:
 490                 cmd->command = CMD_SET_CV_VOLTAGE;
 491                 ivalue = g_variant_get_double(data) * 1000.0;
 492                 WL32(&cmd->data[0], ivalue);
 493                 break;
 494         case SR_CONF_CURRENT_LIMIT:
 495                 cmd->command = CMD_SET_CC_CURRENT;
 496                 ivalue = g_variant_get_double(data) * 10000.0;
 497                 WL32(&cmd->data[0], ivalue);
 498                 break;
 499         case SR_CONF_POWER_TARGET:
 500                 cmd->command = CMD_SET_CW_POWER;
 501                 ivalue = g_variant_get_double(data) * 1000.0;
 502                 WL32(&cmd->data[0], ivalue);
 503                 break;
 504         case SR_CONF_RESISTANCE_TARGET:
 505                 cmd->command = CMD_SET_CR_RESISTANCE;
 506                 ivalue = g_variant_get_double(data) * 1000.0;
 507                 WL32(&cmd->data[0], ivalue);
 508                 break;
 509         case SR_CONF_OVER_VOLTAGE_PROTECTION_THRESHOLD:
 510                 cmd->command = CMD_SET_MAX_VOLTAGE;
 511                 ivalue = g_variant_get_double(data) * 1000.0;
 512                 WL32(&cmd->data[0], ivalue);
 513                 break;
 514         case SR_CONF_OVER_CURRENT_PROTECTION_THRESHOLD:
 515                 cmd->command = CMD_SET_MAX_CURRENT;
 516                 ivalue = g_variant_get_double(data) * 10000.0;
 517                 WL32(&cmd->data[0], ivalue);
 518                 break;
 519
 520         default:
 521                 sr_dbg("%s: Unsupported key: %u (%s)", __func__, key,
 522                         kinfo ? kinfo->name : "unknown");
 523                 ret = SR_ERR_NA;
 524                 goto done;
 525         }
 526
 527         cmd->address = devc->address;
 528         ret = itech_it8500_cmd(sdi, cmd, &response);
 529
 530 done:
 531         g_free(cmd);
 532         g_free(response);
 533
 534         return ret;
 535 }
 536
 537 static int config_list(uint32_t key, GVariant **data,
 538                 const struct sr_dev_inst *sdi,
 539                 const struct sr_channel_group *cg)
 540 {
 541         const struct dev_context *devc;
 542         const struct sr_key_info *kinfo;
 543         GVariantBuilder *b;
 544
 545         devc = sdi ? sdi->priv : NULL;
 546         if (!data)
 547                 return SR_ERR_ARG;
 548
 549         if (!cg)
 550                 return STD_CONFIG_LIST(key, data, sdi, cg,
 551                         scanopts, drvopts, devopts);
 552
 553         kinfo = sr_key_info_get(SR_KEY_CONFIG, key);
 554
 555         switch (key) {
 556         case SR_CONF_DEVICE_OPTIONS:
 557                 *data = std_gvar_array_u32(ARRAY_AND_SIZE(devopts_cg));
 558                 break;
 559         case SR_CONF_SAMPLERATE:
 560                 *data = std_gvar_samplerates_steps(samplerates,
 561                                 1 + devc->max_sample_rate_idx);
 562                 break;
 563         case SR_CONF_REGULATION:
 564                 b = g_variant_builder_new(G_VARIANT_TYPE("as"));
 565                 g_variant_builder_add(b, "s", itech_it8500_mode_to_string(CC));
 566                 g_variant_builder_add(b, "s", itech_it8500_mode_to_string(CV));
 567                 g_variant_builder_add(b, "s", itech_it8500_mode_to_string(CW));
 568                 g_variant_builder_add(b, "s", itech_it8500_mode_to_string(CR));
 569                 *data = g_variant_new("as", b);
 570                 g_variant_builder_unref(b);
 571                 break;
 572         case SR_CONF_VOLTAGE_TARGET:
 573                 if (!devc)
 574                         return SR_ERR_ARG;
 575                 *data = std_gvar_min_max_step(devc->min_voltage,
 576                                 devc->max_voltage, 0.01);
 577                 break;
 578         case SR_CONF_CURRENT_LIMIT:
 579                 if (!devc)
 580                         return SR_ERR_ARG;
 581                 *data = std_gvar_min_max_step(0.0, devc->max_current, 0.001);
 582                 break;
 583         case SR_CONF_POWER_TARGET:
 584                 if (!devc)
 585                         return SR_ERR_ARG;
 586                 *data = std_gvar_min_max_step(0.0, devc->max_power, 0.01);
 587                 break;
 588         case SR_CONF_RESISTANCE_TARGET:
 589                 if (!devc)
 590                         return SR_ERR_ARG;
 591                 *data = std_gvar_min_max_step(devc->min_resistance,
 592                                 devc->max_resistance, 0.01);
 593                 break;
 594
 595         default:
 596                 sr_dbg("%s: Unsupported key: %u (%s)", __func__, key,
 597                         kinfo ? kinfo->name : "unknown");
 598                 return SR_ERR_NA;
 599         }
 600
 601         return SR_OK;
 602 }
 603
 604 static int dev_acquisition_start(const struct sr_dev_inst *sdi)
 605 {
 606         struct dev_context *devc;
 607         struct sr_serial_dev_inst *serial;
 608         int ret;
 609
 610         if (!sdi)
 611                 return SR_ERR_ARG;
 612
 613         devc = sdi->priv;
 614         serial = sdi->conn;
 615
 616         ret = serial_source_add(sdi->session, serial, G_IO_IN,
 617                         (1000.0 / devc->sample_rate),
 618                         itech_it8500_receive_data, (void *)sdi);
 619         if (ret == SR_OK) {
 620                 sr_sw_limits_acquisition_start(&devc->limits);
 621                 std_session_send_df_header(sdi);
 622         }
 623
 624         return ret;
 625 }
 626
 627 static int dev_acquisition_stop(struct sr_dev_inst *sdi)
 628 {
 629         struct sr_serial_dev_inst *serial;
 630
 631         if (!sdi)
 632                 return SR_ERR_ARG;
 633
 634         serial = sdi->conn;
 635
 636         std_session_send_df_end(sdi);
 637         serial_source_remove(sdi->session, serial);
 638
 639         return SR_OK;
 640 }
 641
 642 static int dev_open(struct sr_dev_inst *sdi)
 643 {
 644         struct dev_context *devc;
 645         struct itech_it8500_cmd_packet *cmd, *response;
 646         int ret, res;
 647
 648         if (!sdi)
 649                 return SR_ERR_ARG;
 650
 651         devc = sdi->priv;
 652         ret = std_serial_dev_open(sdi);
 653         if (ret == SR_OK) {
 654                 /* Request the unit to enter remote control mode. */
 655                 response = NULL;
 656                 cmd = g_malloc0(sizeof(*cmd));
 657                 if (cmd) {
 658                         cmd->address = devc->address;
 659                         cmd->command = CMD_SET_REMOTE_MODE;
 660                         cmd->data[0] = 1;
 661                         res = itech_it8500_cmd(sdi, cmd, &response);
 662                         if (res != SR_OK)
 663                                 sr_dbg("Failed to set unit to remote mode");
 664                         g_free(cmd);
 665                         g_free(response);
 666                 }
 667         }
 668
 669         return ret;
 670 }
 671
 672 static int dev_close(struct sr_dev_inst *sdi)
 673 {
 674         struct dev_context *devc;
 675         struct itech_it8500_cmd_packet *cmd, *response;
 676         int ret;
 677
 678         if (!sdi)
 679                 return SR_ERR_ARG;
 680
 681         devc = sdi->priv;
 682         response = NULL;
 683         cmd = g_malloc0(sizeof(*cmd));
 684         if (cmd) {
 685                 /* Request the unit to enter local control mode. */
 686                 cmd->address = devc->address;
 687                 cmd->command = CMD_SET_REMOTE_MODE;
 688                 cmd->data[0] = 0;
 689                 ret = itech_it8500_cmd(sdi, cmd, &response);
 690                 if (ret != SR_OK)
 691                         sr_dbg("Failed to set unit back to local mode: %d",
 692                                 ret);
 693         }
 694
 695         g_free(cmd);
 696         g_free(response);
 697
 698         return std_serial_dev_close(sdi);
 699 }
 700
 701 static void dev_clear_callback(void *priv)
 702 {
 703         struct dev_context *devc;
 704
 705         if (!priv)
 706                 return;
 707
 708         devc = priv;
 709         g_mutex_clear(&devc->mutex);
 710 }
 711
 712 static int dev_clear(const struct sr_dev_driver *di)
 713 {
 714         return std_dev_clear_with_callback(di, dev_clear_callback);
 715 }
 716
 717 static struct sr_dev_driver itech_it8500_driver_info = {
 718         .name = "itech-it8500",
 719         .longname = "ITECH IT8500 series",
 720         .api_version = 1,
 721         .init = std_init,
 722         .cleanup = std_cleanup,
 723         .scan = scan,
 724         .dev_list = std_dev_list,
 725         .dev_clear = dev_clear,
 726         .config_get = config_get,
 727         .config_set = config_set,
 728         .config_list = config_list,
 729         .dev_open = dev_open,
 730         .dev_close = dev_close,
 731         .dev_acquisition_start = dev_acquisition_start,
 732         .dev_acquisition_stop = dev_acquisition_stop,
 733         .context = NULL,
 734 };
 735 SR_REGISTER_DEV_DRIVER(itech_it8500_driver_info);