]> sigrok.org Git - libsigrok.git/blame - src/hardware/itech-it8500/api.c
projects / libsigrok.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
itech-it8500: declaration nits
[libsigrok.git] / src / hardware / itech-it8500 / api.c
CommitLineData
c16effae
TK		 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>
f21b6983 21#include <string.h>
c16effae
TK		 22#include "protocol.h"
23
f21b6983
TK		 24#define MIN_SAMPLE_RATE SR_HZ(1)
25#define MAX_SAMPLE_RATE SR_HZ(60)
26#define DEFAULT_SAMPLE_RATE SR_HZ(10)
c16effae 27
f21b6983
TK		 28static const uint32_t scanopts[] = {
29 SR_CONF_CONN,
30 SR_CONF_SERIALCOMM,
31};
c16effae 32
f21b6983
TK		 33static const uint32_t drvopts[] = {
34 SR_CONF_ELECTRONIC_LOAD,
35};
c16effae 36
f21b6983
TK		 37static 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};
c16effae 43
f21b6983
TK		 44static 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};
c16effae 66
f21b6983
TK		 67static 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};
c16effae 79
f21b6983
TK		 80static const char *default_serial_parameters[] = {
81 "9600/8n1", /* Factory default. */
82 "38400/8n1",
83 "19200/8n1",
84 "4800/8n1",
85 NULL,
86};
c16effae 87
f21b6983 88static struct sr_dev_driver itech_it8500_driver_info;
c16effae 89
f21b6983 90static GSList *scan(struct sr_dev_driver *di, GSList *options)
c16effae 91{
f21b6983
TK		 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 }
c16effae 222
f21b6983
TK		 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
289error:
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 }
c16effae 300
f21b6983 301 return NULL;
c16effae
TK		 302}
303
304static int config_get(uint32_t key, GVariant **data,
f21b6983
TK		 305 const struct sr_dev_inst *sdi,
306 const struct sr_channel_group *cg)
c16effae 307{
f21b6983
TK		 308 struct dev_context *devc;
309 const struct sr_key_info *kinfo;
310 const char *mode;
311 int ret, ival;
312 gboolean bval;
c16effae 313
c16effae
TK		 314 (void)cg;
315
f21b6983
TK		 316 if (!data || !sdi)
317 return SR_ERR_ARG;
318
319 devc = sdi->priv;
320 kinfo = sr_key_info_get(SR_KEY_CONFIG, key);
c16effae 321 ret = SR_OK;
f21b6983 322
c16effae 323 switch (key) {
f21b6983
TK		 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);
78b07caf
GS		 333 if (ret != SR_OK)
334 break;
335 *data = g_variant_new_boolean(devc->load_on);
f21b6983
TK		 336 break;
337 case SR_CONF_REGULATION:
338 ret = itech_it8500_get_status(sdi);
78b07caf
GS		 339 if (ret != SR_OK)
340 break;
341 mode = itech_it8500_mode_to_string(devc->mode);
342 *data = g_variant_new_string(mode);
f21b6983
TK		 343 break;
344 case SR_CONF_VOLTAGE:
345 ret = itech_it8500_get_status(sdi);
78b07caf
GS		 346 if (ret != SR_OK)
347 break;
348 *data = g_variant_new_double(devc->voltage);
f21b6983
TK		 349 break;
350 case SR_CONF_VOLTAGE_TARGET:
351 ret = itech_it8500_get_int(sdi, CMD_GET_CV_VOLTAGE, &ival);
78b07caf
GS		 352 if (ret != SR_OK)
353 break;
354 *data = g_variant_new_double((double)ival / 1000.0);
f21b6983
TK		 355 break;
356 case SR_CONF_CURRENT:
357 ret = itech_it8500_get_status(sdi);
78b07caf
GS		 358 if (ret != SR_OK)
359 break;
360 *data = g_variant_new_double(devc->current);
f21b6983
TK		 361 break;
362 case SR_CONF_CURRENT_LIMIT:
363 ret = itech_it8500_get_int(sdi, CMD_GET_CC_CURRENT, &ival);
78b07caf
GS		 364 if (ret != SR_OK)
365 break;
366 *data = g_variant_new_double((double)ival / 10000.0);
f21b6983
TK		 367 break;
368 case SR_CONF_POWER:
369 ret = itech_it8500_get_status(sdi);
78b07caf
GS		 370 if (ret != SR_OK)
371 break;
372 *data = g_variant_new_double(devc->power);
f21b6983
TK		 373 break;
374 case SR_CONF_POWER_TARGET:
375 ret = itech_it8500_get_int(sdi, CMD_GET_CW_POWER, &ival);
78b07caf
GS		 376 if (ret != SR_OK)
377 break;
378 *data = g_variant_new_double((double)ival / 1000.0);
f21b6983
TK		 379 break;
380 case SR_CONF_RESISTANCE_TARGET:
381 ret = itech_it8500_get_int(sdi, CMD_GET_CR_RESISTANCE, &ival);
78b07caf
GS		 382 if (ret != SR_OK)
383 break;
384 *data = g_variant_new_double((double)ival / 1000.0);
f21b6983
TK		 385 break;
386 case SR_CONF_OVER_VOLTAGE_PROTECTION_ENABLED:
387 *data = g_variant_new_boolean(TRUE);
388 break;
389 case SR_CONF_OVER_VOLTAGE_PROTECTION_ACTIVE:
390 ret = itech_it8500_get_status(sdi);
78b07caf
GS		 391 if (ret != SR_OK)
392 break;
393 bval = devc->demand_state & DS_OV_FLAG;
394 *data = g_variant_new_boolean(bval);
f21b6983
TK		 395 break;
396 case SR_CONF_OVER_VOLTAGE_PROTECTION_THRESHOLD:
397 ret = itech_it8500_get_int(sdi, CMD_GET_MAX_VOLTAGE, &ival);
78b07caf
GS		 398 if (ret != SR_OK)
399 break;
400 *data = g_variant_new_double((double)ival / 1000.0);
f21b6983
TK		 401 break;
402 case SR_CONF_OVER_CURRENT_PROTECTION_ENABLED:
403 *data = g_variant_new_boolean(TRUE);
404 break;
405 case SR_CONF_OVER_CURRENT_PROTECTION_ACTIVE:
406 ret = itech_it8500_get_status(sdi);
78b07caf
GS		 407 if (ret != SR_OK)
408 break;
409 bval = devc->demand_state & DS_OC_FLAG;
410 *data = g_variant_new_boolean(bval);
f21b6983
TK		 411 break;
412 case SR_CONF_OVER_CURRENT_PROTECTION_THRESHOLD:
413 ret = itech_it8500_get_int(sdi, CMD_GET_MAX_CURRENT, &ival);
78b07caf
GS		 414 if (ret != SR_OK)
415 break;
416 *data = g_variant_new_double((double)ival / 10000.0);
f21b6983
TK		 417 break;
418 case SR_CONF_OVER_TEMPERATURE_PROTECTION:
419 *data = g_variant_new_boolean(TRUE);
420 break;
421 case SR_CONF_OVER_TEMPERATURE_PROTECTION_ACTIVE:
422 ret = itech_it8500_get_status(sdi);
78b07caf
GS		 423 if (ret != SR_OK)
424 break;
425 bval = devc->demand_state & DS_OT_FLAG;
426 *data = g_variant_new_boolean(bval);
f21b6983
TK		 427 break;
428 /* Hardware doesn't support under voltage reporting. */
429 case SR_CONF_UNDER_VOLTAGE_CONDITION:
430 case SR_CONF_UNDER_VOLTAGE_CONDITION_ACTIVE:
431 *data = g_variant_new_boolean(FALSE);
432 break;
433 case SR_CONF_UNDER_VOLTAGE_CONDITION_THRESHOLD:
434 *data = g_variant_new_double(0.0);
435 break;
c16effae 436 default:
f21b6983
TK		 437 sr_dbg("%s: Unsupported key: %u (%s)", __func__, key,
438 kinfo ? kinfo->name : "unknown");
439 ret = SR_ERR_NA;
78b07caf 440 break;
c16effae
TK		 441 }
442
443 return ret;
444}
445
446static int config_set(uint32_t key, GVariant *data,
f21b6983
TK		 447 const struct sr_dev_inst *sdi,
448 const struct sr_channel_group *cg)
c16effae 449{
f21b6983
TK		 450 struct dev_context *devc;
451 struct itech_it8500_cmd_packet *cmd, *response;
452 const struct sr_key_info *kinfo;
453 enum itech_it8500_modes mode;
454 int ret, ivalue;
455 uint64_t new_sr;
456 const char *s;
c16effae 457
c16effae
TK		 458 (void)cg;
459
f21b6983
TK		 460 if (!data || !sdi)
461 return SR_ERR_ARG;
462
463 cmd = g_malloc0(sizeof(*cmd));
464 if (!cmd)
465 return SR_ERR_MALLOC;
466
467 devc = sdi->priv;
468 response = NULL;
c16effae 469 ret = SR_OK;
f21b6983
TK		 470
471 kinfo = sr_key_info_get(SR_KEY_CONFIG, key);
472
c16effae 473 switch (key) {
f21b6983
TK		 474 case SR_CONF_LIMIT_MSEC:
475 case SR_CONF_LIMIT_SAMPLES:
476 ret = sr_sw_limits_config_set(&devc->limits, key, data);
78b07caf 477 break;
f21b6983
TK		 478 case SR_CONF_SAMPLERATE:
479 new_sr = g_variant_get_uint64(data);
78b07caf 480 if (new_sr < MIN_SAMPLE_RATE) {
f21b6983 481 ret = SR_ERR_SAMPLERATE;
78b07caf
GS		 482 break;
483 }
484 if (new_sr > samplerates[devc->max_sample_rate_idx]) {
485 ret = SR_ERR_SAMPLERATE;
486 break;
f21b6983
TK		 487 }
488 devc->sample_rate = new_sr;
78b07caf 489 break;
f21b6983
TK		 490 case SR_CONF_ENABLED:
491 cmd->command = CMD_LOAD_ON_OFF;
492 cmd->data[0] = g_variant_get_boolean(data);
493 break;
494 case SR_CONF_REGULATION:
f21b6983
TK		 495 s = g_variant_get_string(data, NULL);
496 if (itech_it8500_string_to_mode(s, &mode) != SR_OK) {
497 ret = SR_ERR_ARG;
78b07caf 498 break;
f21b6983 499 }
78b07caf 500 cmd->command = CMD_SET_MODE;
f21b6983
TK		 501 cmd->data[0] = mode;
502 break;
503 case SR_CONF_VOLTAGE_TARGET:
504 cmd->command = CMD_SET_CV_VOLTAGE;
505 ivalue = g_variant_get_double(data) * 1000.0;
506 WL32(&cmd->data[0], ivalue);
507 break;
508 case SR_CONF_CURRENT_LIMIT:
509 cmd->command = CMD_SET_CC_CURRENT;
510 ivalue = g_variant_get_double(data) * 10000.0;
511 WL32(&cmd->data[0], ivalue);
512 break;
513 case SR_CONF_POWER_TARGET:
514 cmd->command = CMD_SET_CW_POWER;
515 ivalue = g_variant_get_double(data) * 1000.0;
516 WL32(&cmd->data[0], ivalue);
517 break;
518 case SR_CONF_RESISTANCE_TARGET:
519 cmd->command = CMD_SET_CR_RESISTANCE;
520 ivalue = g_variant_get_double(data) * 1000.0;
521 WL32(&cmd->data[0], ivalue);
522 break;
523 case SR_CONF_OVER_VOLTAGE_PROTECTION_THRESHOLD:
524 cmd->command = CMD_SET_MAX_VOLTAGE;
525 ivalue = g_variant_get_double(data) * 1000.0;
526 WL32(&cmd->data[0], ivalue);
527 break;
528 case SR_CONF_OVER_CURRENT_PROTECTION_THRESHOLD:
529 cmd->command = CMD_SET_MAX_CURRENT;
530 ivalue = g_variant_get_double(data) * 10000.0;
531 WL32(&cmd->data[0], ivalue);
532 break;
c16effae 533 default:
f21b6983
TK		 534 sr_dbg("%s: Unsupported key: %u (%s)", __func__, key,
535 kinfo ? kinfo->name : "unknown");
c16effae 536 ret = SR_ERR_NA;
78b07caf 537 break;
c16effae
TK		 538 }
539
78b07caf
GS		 540 if (ret == SR_OK && cmd->command) {
541 cmd->address = devc->address;
542 ret = itech_it8500_cmd(sdi, cmd, &response);
543 }
f21b6983 544
f21b6983
TK		 545 g_free(cmd);
546 g_free(response);
547
c16effae
TK		 548 return ret;
549}
550
551static int config_list(uint32_t key, GVariant **data,
f21b6983
TK		 552 const struct sr_dev_inst *sdi,
553 const struct sr_channel_group *cg)
c16effae 554{
f21b6983
TK		 555 const struct dev_context *devc;
556 const struct sr_key_info *kinfo;
557 GVariantBuilder *b;
c16effae 558
f21b6983
TK		 559 devc = sdi ? sdi->priv : NULL;
560 if (!data)
561 return SR_ERR_ARG;
562
563 if (!cg)
564 return STD_CONFIG_LIST(key, data, sdi, cg,
565 scanopts, drvopts, devopts);
566
567 kinfo = sr_key_info_get(SR_KEY_CONFIG, key);
c16effae 568
c16effae 569 switch (key) {
f21b6983
TK		 570 case SR_CONF_DEVICE_OPTIONS:
571 *data = std_gvar_array_u32(ARRAY_AND_SIZE(devopts_cg));
572 break;
573 case SR_CONF_SAMPLERATE:
574 *data = std_gvar_samplerates_steps(samplerates,
575 1 + devc->max_sample_rate_idx);
576 break;
577 case SR_CONF_REGULATION:
578 b = g_variant_builder_new(G_VARIANT_TYPE("as"));
579 g_variant_builder_add(b, "s", itech_it8500_mode_to_string(CC));
580 g_variant_builder_add(b, "s", itech_it8500_mode_to_string(CV));
581 g_variant_builder_add(b, "s", itech_it8500_mode_to_string(CW));
582 g_variant_builder_add(b, "s", itech_it8500_mode_to_string(CR));
583 *data = g_variant_new("as", b);
584 g_variant_builder_unref(b);
585 break;
586 case SR_CONF_VOLTAGE_TARGET:
587 if (!devc)
588 return SR_ERR_ARG;
589 *data = std_gvar_min_max_step(devc->min_voltage,
590 devc->max_voltage, 0.01);
591 break;
592 case SR_CONF_CURRENT_LIMIT:
593 if (!devc)
594 return SR_ERR_ARG;
595 *data = std_gvar_min_max_step(0.0, devc->max_current, 0.001);
596 break;
597 case SR_CONF_POWER_TARGET:
598 if (!devc)
599 return SR_ERR_ARG;
600 *data = std_gvar_min_max_step(0.0, devc->max_power, 0.01);
601 break;
602 case SR_CONF_RESISTANCE_TARGET:
603 if (!devc)
604 return SR_ERR_ARG;
605 *data = std_gvar_min_max_step(devc->min_resistance,
606 devc->max_resistance, 0.01);
607 break;
608
c16effae 609 default:
f21b6983
TK		 610 sr_dbg("%s: Unsupported key: %u (%s)", __func__, key,
611 kinfo ? kinfo->name : "unknown");
c16effae
TK		 612 return SR_ERR_NA;
613 }
614
f21b6983 615 return SR_OK;
c16effae
TK		 616}
617
618static int dev_acquisition_start(const struct sr_dev_inst *sdi)
619{
f21b6983
TK		 620 struct dev_context *devc;
621 struct sr_serial_dev_inst *serial;
622 int ret;
c16effae 623
f21b6983
TK		 624 if (!sdi)
625 return SR_ERR_ARG;
c16effae 626
f21b6983
TK		 627 devc = sdi->priv;
628 serial = sdi->conn;
629
8c8fff47
GS		 630 ret = serial_source_add(sdi->session, serial,
631 G_IO_IN, (1000.0 / devc->sample_rate),
f21b6983
TK		 632 itech_it8500_receive_data, (void *)sdi);
633 if (ret == SR_OK) {
634 sr_sw_limits_acquisition_start(&devc->limits);
635 std_session_send_df_header(sdi);
636 }
637
638 return ret;
c16effae
TK		 639}
640
641static int dev_acquisition_stop(struct sr_dev_inst *sdi)
642{
f21b6983
TK		 643 struct sr_serial_dev_inst *serial;
644
645 if (!sdi)
646 return SR_ERR_ARG;
c16effae 647
f21b6983
TK		 648 serial = sdi->conn;
649
650 std_session_send_df_end(sdi);
651 serial_source_remove(sdi->session, serial);
c16effae
TK		 652
653 return SR_OK;
654}
655
f21b6983
TK		 656static int dev_open(struct sr_dev_inst *sdi)
657{
658 struct dev_context *devc;
659 struct itech_it8500_cmd_packet *cmd, *response;
660 int ret, res;
661
662 if (!sdi)
663 return SR_ERR_ARG;
664
665 devc = sdi->priv;
666 ret = std_serial_dev_open(sdi);
667 if (ret == SR_OK) {
668 /* Request the unit to enter remote control mode. */
669 response = NULL;
670 cmd = g_malloc0(sizeof(*cmd));
671 if (cmd) {
672 cmd->address = devc->address;
673 cmd->command = CMD_SET_REMOTE_MODE;
674 cmd->data[0] = 1;
675 res = itech_it8500_cmd(sdi, cmd, &response);
676 if (res != SR_OK)
677 sr_dbg("Failed to set unit to remote mode");
678 g_free(cmd);
679 g_free(response);
680 }
681 }
682
683 return ret;
684}
685
686static int dev_close(struct sr_dev_inst *sdi)
687{
688 struct dev_context *devc;
689 struct itech_it8500_cmd_packet *cmd, *response;
690 int ret;
691
692 if (!sdi)
693 return SR_ERR_ARG;
694
695 devc = sdi->priv;
696 response = NULL;
697 cmd = g_malloc0(sizeof(*cmd));
698 if (cmd) {
699 /* Request the unit to enter local control mode. */
700 cmd->address = devc->address;
701 cmd->command = CMD_SET_REMOTE_MODE;
702 cmd->data[0] = 0;
703 ret = itech_it8500_cmd(sdi, cmd, &response);
704 if (ret != SR_OK)
705 sr_dbg("Failed to set unit back to local mode: %d",
706 ret);
707 }
708
709 g_free(cmd);
710 g_free(response);
711
712 return std_serial_dev_close(sdi);
713}
714
715static void dev_clear_callback(void *priv)
716{
717 struct dev_context *devc;
718
719 if (!priv)
720 return;
721
722 devc = priv;
723 g_mutex_clear(&devc->mutex);
724}
725
726static int dev_clear(const struct sr_dev_driver *di)
727{
728 return std_dev_clear_with_callback(di, dev_clear_callback);
729}
730
c16effae
TK		 731static struct sr_dev_driver itech_it8500_driver_info = {
732 .name = "itech-it8500",
f21b6983 733 .longname = "ITECH IT8500 series",
c16effae
TK		 734 .api_version = 1,
735 .init = std_init,
736 .cleanup = std_cleanup,
737 .scan = scan,
738 .dev_list = std_dev_list,
f21b6983 739 .dev_clear = dev_clear,
c16effae
TK		 740 .config_get = config_get,
741 .config_set = config_set,
742 .config_list = config_list,
743 .dev_open = dev_open,
744 .dev_close = dev_close,
745 .dev_acquisition_start = dev_acquisition_start,
746 .dev_acquisition_stop = dev_acquisition_stop,
747 .context = NULL,
748};
749SR_REGISTER_DEV_DRIVER(itech_it8500_driver_info);
Hardware access and backend lib