src/hardware/cem-dt-885x/protocol.c

   1 /*
   2  * This file is part of the libsigrok project.
   3  *
   4  * Copyright (C) 2013 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 <string.h>
  21 #include "protocol.h"
  22
  23 /* Length of expected payload for each token. */
  24 static const int token_payloads[][2] = {
  25         { TOKEN_WEIGHT_TIME_FAST, 0 },
  26         { TOKEN_WEIGHT_TIME_SLOW, 0 },
  27         { TOKEN_HOLD_MAX, 0 },
  28         { TOKEN_HOLD_MIN, 0 },
  29         { TOKEN_TIME, 3 },
  30         { TOKEN_MEAS_RANGE_OVER, 0 },
  31         { TOKEN_MEAS_RANGE_UNDER, 0 },
  32         { TOKEN_STORE_FULL, 0 },
  33         { TOKEN_RECORDING_ON, 0 },
  34         { TOKEN_MEAS_WAS_READOUT, 1 },
  35         { TOKEN_MEAS_WAS_BARGRAPH, 0 },
  36         { TOKEN_MEASUREMENT, 2 },
  37         { TOKEN_HOLD_NONE, 0 },
  38         { TOKEN_BATTERY_LOW, 0 },
  39         { TOKEN_MEAS_RANGE_OK, 0 },
  40         { TOKEN_STORE_OK, 0 },
  41         { TOKEN_RECORDING_OFF, 0 },
  42         { TOKEN_WEIGHT_FREQ_A, 1 },
  43         { TOKEN_WEIGHT_FREQ_C, 1 },
  44         { TOKEN_BATTERY_OK, 0 },
  45         { TOKEN_MEAS_RANGE_30_80, 0 },
  46         { TOKEN_MEAS_RANGE_30_130, 0 },
  47         { TOKEN_MEAS_RANGE_50_100, 0 },
  48         { TOKEN_MEAS_RANGE_80_130, 0 },
  49 };
  50
  51 static int find_token_payload_len(unsigned char c)
  52 {
  53         unsigned int i;
  54
  55         for (i = 0; i < ARRAY_SIZE(token_payloads); i++) {
  56                 if (token_payloads[i][0] == c)
  57                         return token_payloads[i][1];
  58         }
  59
  60         return -1;
  61 }
  62
  63 /* Process measurement or setting (0xa5 command). */
  64 static void process_mset(const struct sr_dev_inst *sdi)
  65 {
  66         struct dev_context *devc;
  67         struct sr_datafeed_packet packet;
  68         struct sr_datafeed_analog analog;
  69         GString *dbg;
  70         float fvalue;
  71         int i;
  72
  73         devc = sdi->priv;
  74         if (sr_log_loglevel_get() >= SR_LOG_SPEW) {
  75                 dbg = g_string_sized_new(128);
  76                 g_string_printf(dbg, "got command 0x%.2x token 0x%.2x",
  77                                 devc->cmd, devc->token);
  78                 if (devc->buf_len) {
  79                         g_string_append_printf(dbg, " payload");
  80                         for (i = 0; i < devc->buf_len; i++)
  81                                 g_string_append_printf(dbg, " %.2x", devc->buf[i]);
  82                 }
  83                 sr_spew("%s", dbg->str);
  84                 g_string_free(dbg, TRUE);
  85         }
  86
  87         switch(devc->token) {
  88         case TOKEN_WEIGHT_TIME_FAST:
  89                 devc->cur_mqflags |= SR_MQFLAG_SPL_TIME_WEIGHT_F;
  90                 devc->cur_mqflags &= ~SR_MQFLAG_SPL_TIME_WEIGHT_S;
  91                 break;
  92         case TOKEN_WEIGHT_TIME_SLOW:
  93                 devc->cur_mqflags |= SR_MQFLAG_SPL_TIME_WEIGHT_S;
  94                 devc->cur_mqflags &= ~SR_MQFLAG_SPL_TIME_WEIGHT_F;
  95                 break;
  96         case TOKEN_WEIGHT_FREQ_A:
  97                 devc->cur_mqflags |= SR_MQFLAG_SPL_FREQ_WEIGHT_A;
  98                 devc->cur_mqflags &= ~SR_MQFLAG_SPL_FREQ_WEIGHT_C;
  99                 break;
 100         case TOKEN_WEIGHT_FREQ_C:
 101                 devc->cur_mqflags |= SR_MQFLAG_SPL_FREQ_WEIGHT_C;
 102                 devc->cur_mqflags &= ~SR_MQFLAG_SPL_FREQ_WEIGHT_A;
 103                 break;
 104         case TOKEN_HOLD_MAX:
 105                 devc->cur_mqflags |= SR_MQFLAG_HOLD | SR_MQFLAG_MAX;
 106                 devc->cur_mqflags &= ~SR_MQFLAG_MIN;
 107                 break;
 108         case TOKEN_HOLD_MIN:
 109                 devc->cur_mqflags |= SR_MQFLAG_HOLD | SR_MQFLAG_MIN;
 110                 devc->cur_mqflags &= ~SR_MQFLAG_MAX;
 111                 break;
 112         case TOKEN_HOLD_NONE:
 113                 devc->cur_mqflags &= ~(SR_MQFLAG_MAX | SR_MQFLAG_MIN | SR_MQFLAG_HOLD);
 114                 break;
 115         case TOKEN_MEASUREMENT:
 116                 fvalue = ((devc->buf[0] & 0xf0) >> 4) * 100;
 117                 fvalue += (devc->buf[0] & 0x0f) * 10;
 118                 fvalue += ((devc->buf[1] & 0xf0) >> 4);
 119                 fvalue += (devc->buf[1] & 0x0f) / 10.0;
 120                 devc->last_spl = fvalue;
 121                 break;
 122         case TOKEN_MEAS_WAS_READOUT:
 123         case TOKEN_MEAS_WAS_BARGRAPH:
 124                 if (devc->cur_mqflags & (SR_MQFLAG_MAX | SR_MQFLAG_MIN)) {
 125                         if (devc->token == TOKEN_MEAS_WAS_BARGRAPH) {
 126                                 /* The device still sends bargraph measurements even
 127                                  * when in max/min hold mode. Suppress them here, unless
 128                                  * they're readout values. This duplicates the behavior
 129                                  * of the device display exactly. */
 130                                 break;
 131                         }
 132                 }
 133                 memset(&analog, 0, sizeof(struct sr_datafeed_analog));
 134                 analog.mq = SR_MQ_SOUND_PRESSURE_LEVEL;
 135                 analog.mqflags = devc->cur_mqflags;
 136                 analog.unit = SR_UNIT_DECIBEL_SPL;
 137                 analog.channels = sdi->channels;
 138                 analog.num_samples = 1;
 139                 analog.data = &devc->last_spl;
 140                 packet.type = SR_DF_ANALOG;
 141                 packet.payload = &analog;
 142                 sr_session_send(devc->cb_data, &packet);
 143
 144                 devc->num_samples++;
 145                 if (devc->limit_samples && devc->num_samples >= devc->limit_samples)
 146                         sdi->driver->dev_acquisition_stop((struct sr_dev_inst *)sdi,
 147                                         devc->cb_data);
 148                 break;
 149         case TOKEN_RECORDING_ON:
 150                 devc->recording = TRUE;
 151                 break;
 152         case TOKEN_RECORDING_OFF:
 153                 devc->recording = FALSE;
 154                 break;
 155         case TOKEN_MEAS_RANGE_30_80:
 156         case TOKEN_MEAS_RANGE_30_130:
 157         case TOKEN_MEAS_RANGE_50_100:
 158         case TOKEN_MEAS_RANGE_80_130:
 159                 devc->cur_meas_range = devc->token;
 160                 break;
 161         case TOKEN_TIME:
 162         case TOKEN_STORE_OK:
 163         case TOKEN_STORE_FULL:
 164         case TOKEN_BATTERY_OK:
 165         case TOKEN_BATTERY_LOW:
 166         case TOKEN_MEAS_RANGE_OK:
 167         case TOKEN_MEAS_RANGE_OVER:
 168         case TOKEN_MEAS_RANGE_UNDER:
 169                 /* Not useful, or not expressable in sigrok. */
 170                 break;
 171         }
 172
 173 }
 174
 175 static void send_data(const struct sr_dev_inst *sdi, unsigned char *data,
 176                 uint64_t num_samples)
 177 {
 178         struct dev_context *devc;
 179         struct sr_datafeed_packet packet;
 180         struct sr_datafeed_analog analog;
 181         float fbuf[SAMPLES_PER_PACKET];
 182         unsigned int i;
 183
 184         devc = sdi->priv;
 185
 186         for (i = 0; i < num_samples; i ++) {
 187                 fbuf[i] = ((data[i * 2] & 0xf0) >> 4) * 100;
 188                 fbuf[i] += (data[i * 2] & 0x0f) * 10;
 189                 fbuf[i] += ((data[i * 2 + 1] & 0xf0) >> 4);
 190                 fbuf[i] += (data[i * 2 + 1] & 0x0f) / 10.0;
 191         }
 192         memset(&analog, 0, sizeof(struct sr_datafeed_analog));
 193         analog.mq = SR_MQ_SOUND_PRESSURE_LEVEL;
 194         analog.mqflags = devc->cur_mqflags;
 195         analog.unit = SR_UNIT_DECIBEL_SPL;
 196         analog.channels = sdi->channels;
 197         analog.num_samples = num_samples;
 198         analog.data = fbuf;
 199         packet.type = SR_DF_ANALOG;
 200         packet.payload = &analog;
 201         sr_session_send(devc->cb_data, &packet);
 202
 203         devc->num_samples += analog.num_samples;
 204         if (devc->limit_samples && devc->num_samples >= devc->limit_samples)
 205                 sdi->driver->dev_acquisition_stop((struct sr_dev_inst *)sdi,
 206                                 devc->cb_data);
 207
 208         return;
 209 }
 210
 211 static void process_byte(const struct sr_dev_inst *sdi, const unsigned char c,
 212                 int handle_packets)
 213 {
 214         struct dev_context *devc;
 215         struct sr_datafeed_packet packet;
 216         struct sr_datafeed_meta meta;
 217         struct sr_config *src;
 218         gint64 cur_time;
 219         int len;
 220
 221         if (!(devc = sdi->priv))
 222                 return;
 223
 224         if (c == 0xff) {
 225                 /* Device is in hold mode */
 226                 devc->cur_mqflags |= SR_MQFLAG_HOLD;
 227
 228                 if (devc->hold_last_sent == 0) {
 229                         /* First hold notification. */
 230                         devc->hold_last_sent = g_get_monotonic_time();
 231                         /* When the device leaves hold mode, it starts from scratch. */
 232                         devc->state = ST_INIT;
 233                 } else {
 234                         cur_time = g_get_monotonic_time();
 235                         if (cur_time - devc->hold_last_sent > HOLD_REPEAT_INTERVAL) {
 236                                 /* Force the last measurement out again. */
 237                                 devc->cmd = 0xa5;
 238                                 devc->token = TOKEN_MEAS_WAS_READOUT;
 239                                 if (handle_packets)
 240                                         process_mset(sdi);
 241                                 devc->hold_last_sent = cur_time;
 242                         }
 243                 }
 244
 245                 return;
 246         }
 247         devc->cur_mqflags &= ~SR_MQFLAG_HOLD;
 248         devc->hold_last_sent = 0;
 249
 250         if (devc->state == ST_INIT) {
 251                 if (c == 0xa5) {
 252                         devc->cmd = c;
 253                         devc->token = 0x00;
 254                         devc->state = ST_GET_TOKEN;
 255                 } else if (c == 0xbb) {
 256                         devc->cmd = c;
 257                         devc->buf_len = 0;
 258                         devc->state = ST_GET_LOG_HEADER;
 259                         sr_dbg("got command 0xbb");
 260                 }
 261         } else if (devc->state == ST_GET_TOKEN) {
 262                 devc->token = c;
 263                 devc->buf_len = 0;
 264                 len = find_token_payload_len(devc->token);
 265                 if (len == -1 || len > 0) {
 266                         devc->buf_len = 0;
 267                         devc->state = ST_GET_DATA;
 268                 } else {
 269                         if (handle_packets)
 270                                 process_mset(sdi);
 271                         devc->state = ST_INIT;
 272                 }
 273         } else if (devc->state == ST_GET_DATA) {
 274                 len = find_token_payload_len(devc->token);
 275                 if (len == -1) {
 276                         /* We don't know this token. */
 277                         sr_dbg("Unknown 0xa5 token 0x%.2x", devc->token);
 278                         if (c == 0xa5 || c == 0xbb) {
 279                                 /* Looks like a new command however. */
 280                                 if (handle_packets)
 281                                         process_mset(sdi);
 282                                 devc->state = ST_INIT;
 283                         } else {
 284                                 devc->buf[devc->buf_len++] = c;
 285                                 if (devc->buf_len > BUF_SIZE) {
 286                                         /* Shouldn't happen, ignore. */
 287                                         devc->state = ST_INIT;
 288                                 }
 289                         }
 290                 } else {
 291                         devc->buf[devc->buf_len++] = c;
 292                         if (devc->buf_len == len) {
 293                                 if (handle_packets)
 294                                         process_mset(sdi);
 295                                 devc->state = ST_INIT;
 296                         } else if (devc->buf_len > BUF_SIZE) {
 297                                 /* Shouldn't happen, ignore. */
 298                                 devc->state = ST_INIT;
 299                         }
 300                 }
 301         } else if (devc->state == ST_GET_LOG_HEADER) {
 302                 sr_dbg("log header: 0x%.2x", c);
 303                 if (devc->buf_len < 2)
 304                         devc->buf[devc->buf_len++] = c;
 305                 if (devc->buf_len == 2) {
 306                         sr_dbg("Device says it has %d bytes stored.",
 307                                         ((devc->buf[0] << 8) + devc->buf[1]) - 100);
 308                         devc->buf_len = 0;
 309                         devc->state = ST_GET_LOG_RECORD_META;
 310                 }
 311         } else if (devc->state == ST_GET_LOG_RECORD_META) {
 312                 sr_dbg("log meta: 0x%.2x", c);
 313                 if (c == RECORD_END) {
 314                         devc->state = ST_INIT;
 315                         /* Stop acquisition after transferring all stored
 316                          * records. Otherwise the frontend would have no
 317                          * way to tell where stored data ends and live
 318                          * measurements begin. */
 319                         sdi->driver->dev_acquisition_stop((struct sr_dev_inst *)sdi,
 320                                         devc->cb_data);
 321                 } else if (c == RECORD_DATA) {
 322                         devc->buf_len = 0;
 323                         devc->state = ST_GET_LOG_RECORD_DATA;
 324                 } else {
 325                         /* RECORD_DBA/RECORD_DBC + 7 bytes of metadata */
 326                         devc->buf[devc->buf_len++] = c;
 327                         if (devc->buf_len < 8)
 328                                 /* Keep filling up the record header. */
 329                                 return;
 330                         if (devc->buf[0] == RECORD_DBA)
 331                                 devc->cur_mqflags = SR_MQFLAG_SPL_FREQ_WEIGHT_A;
 332                         else if (devc->buf[0] == RECORD_DBC)
 333                                 devc->cur_mqflags = SR_MQFLAG_SPL_FREQ_WEIGHT_C;
 334                         else {
 335                                 /* Shouldn't happen. */
 336                                 sr_dbg("Unknown record token 0x%.2x", c);
 337                                 return;
 338                         }
 339                         packet.type = SR_DF_META;
 340                         packet.payload = &meta;
 341                         src = sr_config_new(SR_CONF_SAMPLE_INTERVAL,
 342                                         g_variant_new_uint64(devc->buf[7] * 1000));
 343                         meta.config = g_slist_append(NULL, src);
 344                         sr_session_send(devc->cb_data, &packet);
 345                         g_free(src);
 346                         devc->buf_len = 0;
 347                 }
 348         } else if (devc->state == ST_GET_LOG_RECORD_DATA) {
 349                 sr_dbg("log data: 0x%.2x", c);
 350                 if (c == RECORD_DBA || c == RECORD_DBC || c == RECORD_DATA || c == RECORD_END) {
 351                         /* Work around off-by-one bug in device firmware. This
 352                          * happens only on the last record, i.e. before RECORD_END */
 353                         if (devc->buf_len & 1)
 354                                 devc->buf_len--;
 355                         /* Done with this set of samples */
 356                         send_data(sdi, devc->buf, devc->buf_len / 2);
 357                         devc->buf_len = 0;
 358
 359                         /* Process this meta marker in the right state. */
 360                         devc->state = ST_GET_LOG_RECORD_META;
 361                         process_byte(sdi, c, handle_packets);
 362                 } else {
 363                         devc->buf[devc->buf_len++] = c;
 364                         if (devc->buf_len == SAMPLES_PER_PACKET * 2) {
 365                                 send_data(sdi, devc->buf, devc->buf_len / 2);
 366                                 devc->buf_len = 0;
 367                         }
 368                 }
 369         }
 370
 371 }
 372
 373 SR_PRIV int cem_dt_885x_receive_data(int fd, int revents, void *cb_data)
 374 {
 375         const struct sr_dev_inst *sdi;
 376         struct dev_context *devc;
 377         struct sr_serial_dev_inst *serial;
 378         unsigned char c, cmd;
 379
 380         (void)fd;
 381
 382         if (!(sdi = cb_data))
 383                 return TRUE;
 384
 385         devc = sdi->priv;
 386         serial = sdi->conn;
 387         if (revents == G_IO_IN) {
 388                 if (serial_read_nonblocking(serial, &c, 1) != 1)
 389                         return TRUE;
 390                 process_byte(sdi, c, TRUE);
 391
 392                 if (devc->enable_data_source_memory) {
 393                         if (devc->state == ST_GET_LOG_HEADER) {
 394                                 /* Memory transfer started. */
 395                                 devc->enable_data_source_memory = FALSE;
 396                         } else {
 397                                 /* Tell device to start transferring from memory. */
 398                                 cmd = CMD_TRANSFER_MEMORY;
 399                                 serial_write_nonblocking(serial, &cmd, 1);
 400                         }
 401                 }
 402         }
 403
 404         return TRUE;
 405 }
 406
 407 static int wait_for_token(const struct sr_dev_inst *sdi, int8_t *tokens, int timeout)
 408 {
 409         struct dev_context *devc;
 410         struct sr_serial_dev_inst *serial;
 411         gint64 start_time;
 412         int i;
 413         unsigned char c;
 414
 415         serial = sdi->conn;
 416         devc = sdi->priv;
 417         devc->state = ST_INIT;
 418         start_time = g_get_monotonic_time() / 1000;
 419         while (TRUE) {
 420                 if (serial_read_nonblocking(serial, &c, 1) != 1)
 421                         /* Device might have gone away. */
 422                         return SR_ERR;
 423                 process_byte(sdi, c, FALSE);
 424                 if (devc->state != ST_INIT)
 425                         /* Wait for a whole packet to get processed. */
 426                         continue;
 427                 for (i = 0; tokens[i] != -1; i++) {
 428                         if (devc->token == tokens[i]) {
 429                                 sr_spew("wait_for_token: got token 0x%.2x", devc->token);
 430                                 return SR_OK;
 431                         }
 432                 }
 433                 if (timeout && g_get_monotonic_time() / 1000 - start_time > timeout)
 434                         return SR_ERR_TIMEOUT;
 435         }
 436
 437         return SR_OK;
 438 }
 439
 440 /* cmd is the command to send, tokens are the tokens that denote the state
 441  * which the command affects. The first token is the desired state. */
 442 static int cem_dt_885x_toggle(const struct sr_dev_inst *sdi, uint8_t cmd,
 443                 int8_t *tokens, int timeout)
 444 {
 445         struct dev_context *devc;
 446         struct sr_serial_dev_inst *serial;
 447
 448         serial = sdi->conn;
 449         devc = sdi->priv;
 450
 451         /* The device doesn't respond to commands very well. The
 452          * only thing to do is wait for the token that will confirm
 453          * whether the command worked or not, and resend if needed. */
 454         while (TRUE) {
 455                 if (serial_write_nonblocking(serial, (const void *)&cmd, 1) != 1)
 456                         return SR_ERR;
 457                 if (wait_for_token(sdi, tokens, timeout) == SR_ERR)
 458                         return SR_ERR;
 459                 if (devc->token == tokens[0])
 460                         /* It worked. */
 461                         break;
 462         }
 463
 464         return SR_OK;
 465 }
 466
 467 SR_PRIV gboolean cem_dt_885x_recording_get(const struct sr_dev_inst *sdi,
 468                 int *state)
 469 {
 470         struct dev_context *devc;
 471         int8_t tokens[5];
 472
 473         devc = sdi->priv;
 474         if (devc->recording == -1) {
 475                 /* Didn't pick up device state yet. */
 476                 tokens[0] = TOKEN_RECORDING_ON;
 477                 tokens[1] = TOKEN_RECORDING_OFF;
 478                 tokens[2] = -1;
 479                 if (wait_for_token(sdi, tokens, 510) != SR_OK)
 480                         return SR_ERR;
 481         }
 482         *state = devc->token == TOKEN_RECORDING_ON;
 483
 484         return SR_OK;
 485 }
 486
 487 SR_PRIV int cem_dt_885x_recording_set(const struct sr_dev_inst *sdi,
 488                 gboolean state)
 489 {
 490         struct dev_context *devc;
 491         int ret;
 492         int8_t tokens[5];
 493
 494         devc = sdi->priv;
 495
 496         /* The toggle below needs the desired state in first position. */
 497         if (state) {
 498                 tokens[0] = TOKEN_RECORDING_ON;
 499                 tokens[1] = TOKEN_RECORDING_OFF;
 500         } else {
 501                 tokens[0] = TOKEN_RECORDING_OFF;
 502                 tokens[1] = TOKEN_RECORDING_ON;
 503         }
 504         tokens[2] = -1;
 505
 506         if (devc->recording == -1) {
 507                 /* Didn't pick up device state yet. */
 508                 if (wait_for_token(sdi, tokens, 0) != SR_OK)
 509                         return SR_ERR;
 510                 if (devc->token == tokens[0])
 511                         /* Nothing to do. */
 512                         return SR_OK;
 513         } else if (devc->recording == state)
 514                 /* Nothing to do. */
 515                 return SR_OK;
 516
 517         /* Recording state notifications are sent at 2Hz, so allow just over
 518          * that, 510ms, for the state to come in. */
 519         ret = cem_dt_885x_toggle(sdi, CMD_TOGGLE_RECORDING, tokens, 510);
 520
 521         return ret;
 522 }
 523
 524 SR_PRIV int cem_dt_885x_weight_freq_get(const struct sr_dev_inst *sdi)
 525 {
 526         struct dev_context *devc;
 527         int cur_setting;
 528         int8_t tokens[5];
 529
 530         devc = sdi->priv;
 531
 532         cur_setting = devc->cur_mqflags & (SR_MQFLAG_SPL_FREQ_WEIGHT_A | SR_MQFLAG_SPL_FREQ_WEIGHT_C);
 533         if (cur_setting == 0) {
 534                 /* Didn't pick up device state yet. */
 535                 tokens[0] = TOKEN_WEIGHT_FREQ_A;
 536                 tokens[1] = TOKEN_WEIGHT_FREQ_C;
 537                 tokens[2] = -1;
 538                 if (wait_for_token(sdi, tokens, 0) != SR_OK)
 539                         return SR_ERR;
 540                 if (devc->token == TOKEN_WEIGHT_FREQ_A)
 541                         return SR_MQFLAG_SPL_FREQ_WEIGHT_A;
 542                 else
 543                         return SR_MQFLAG_SPL_FREQ_WEIGHT_C;
 544         } else
 545                 return cur_setting;
 546 }
 547
 548 SR_PRIV int cem_dt_885x_weight_freq_set(const struct sr_dev_inst *sdi, int freqw)
 549 {
 550         struct dev_context *devc;
 551         int cur_setting, ret;
 552         int8_t tokens[5];
 553
 554         devc = sdi->priv;
 555
 556         cur_setting = devc->cur_mqflags & (SR_MQFLAG_SPL_FREQ_WEIGHT_A | SR_MQFLAG_SPL_FREQ_WEIGHT_C);
 557         if (cur_setting == freqw)
 558                 /* Already set to this frequency weighting. */
 559                 return SR_OK;
 560
 561         /* The toggle below needs the desired state in first position. */
 562         if (freqw == SR_MQFLAG_SPL_FREQ_WEIGHT_A) {
 563                 tokens[0] = TOKEN_WEIGHT_FREQ_A;
 564                 tokens[1] = TOKEN_WEIGHT_FREQ_C;
 565         } else {
 566                 tokens[0] = TOKEN_WEIGHT_FREQ_C;
 567                 tokens[1] = TOKEN_WEIGHT_FREQ_A;
 568         }
 569         tokens[2] = -1;
 570
 571         if (cur_setting == 0) {
 572                 /* Didn't pick up device state yet. */
 573                 if (wait_for_token(sdi, tokens, 0) != SR_OK)
 574                         return SR_ERR;
 575                 if (devc->token == tokens[0])
 576                         /* Nothing to do. */
 577                         return SR_OK;
 578         }
 579
 580         /* 10ms timeout seems to work best for this. */
 581         ret = cem_dt_885x_toggle(sdi, CMD_TOGGLE_WEIGHT_FREQ, tokens, 10);
 582
 583         return ret;
 584 }
 585
 586 SR_PRIV int cem_dt_885x_weight_time_get(const struct sr_dev_inst *sdi)
 587 {
 588         struct dev_context *devc;
 589         int cur_setting;
 590         int8_t tokens[5];
 591
 592         devc = sdi->priv;
 593
 594         cur_setting = devc->cur_mqflags & (SR_MQFLAG_SPL_TIME_WEIGHT_F | SR_MQFLAG_SPL_TIME_WEIGHT_S);
 595         if (cur_setting == 0) {
 596                 /* Didn't pick up device state yet. */
 597                 tokens[0] = TOKEN_WEIGHT_TIME_FAST;
 598                 tokens[1] = TOKEN_WEIGHT_TIME_SLOW;
 599                 tokens[2] = -1;
 600                 if (wait_for_token(sdi, tokens, 0) != SR_OK)
 601                         return SR_ERR;
 602                 if (devc->token == TOKEN_WEIGHT_TIME_FAST)
 603                         return SR_MQFLAG_SPL_TIME_WEIGHT_F;
 604                 else
 605                         return SR_MQFLAG_SPL_TIME_WEIGHT_S;
 606         } else
 607                 return cur_setting;
 608 }
 609
 610 SR_PRIV int cem_dt_885x_weight_time_set(const struct sr_dev_inst *sdi, int timew)
 611 {
 612         struct dev_context *devc;
 613         int cur_setting, ret;
 614         int8_t tokens[5];
 615
 616         devc = sdi->priv;
 617
 618         cur_setting = devc->cur_mqflags & (SR_MQFLAG_SPL_TIME_WEIGHT_F | SR_MQFLAG_SPL_TIME_WEIGHT_S);
 619         if (cur_setting == timew)
 620                 /* Already set to this time weighting. */
 621                 return SR_OK;
 622
 623         /* The toggle below needs the desired state in first position. */
 624         if (timew == SR_MQFLAG_SPL_TIME_WEIGHT_F) {
 625                 tokens[0] = TOKEN_WEIGHT_TIME_FAST;
 626                 tokens[1] = TOKEN_WEIGHT_TIME_SLOW;
 627         } else {
 628                 tokens[0] = TOKEN_WEIGHT_TIME_SLOW;
 629                 tokens[1] = TOKEN_WEIGHT_TIME_FAST;
 630         }
 631         tokens[2] = -1;
 632
 633         if (cur_setting == 0) {
 634                 /* Didn't pick up device state yet. */
 635                 if (wait_for_token(sdi, tokens, 0) != SR_OK)
 636                         return SR_ERR;
 637                 if (devc->token == tokens[0])
 638                         /* Nothing to do. */
 639                         return SR_OK;
 640         }
 641
 642         /* 51ms timeout seems to work best for this. */
 643         ret = cem_dt_885x_toggle(sdi, CMD_TOGGLE_WEIGHT_TIME, tokens, 51);
 644
 645         return ret;
 646 }
 647
 648 SR_PRIV int cem_dt_885x_holdmode_get(const struct sr_dev_inst *sdi,
 649                 gboolean *holdmode)
 650 {
 651         struct dev_context *devc;
 652         int8_t tokens[5];
 653
 654         devc = sdi->priv;
 655
 656         if (devc->cur_mqflags == 0) {
 657                 tokens[0] = TOKEN_HOLD_MAX;
 658                 tokens[1] = TOKEN_HOLD_MIN;
 659                 tokens[2] = TOKEN_HOLD_NONE;
 660                 tokens[3] = -1;
 661                 if (wait_for_token(sdi, tokens, 0) != SR_OK)
 662                         return SR_ERR;
 663                 if (devc->token == TOKEN_HOLD_MAX)
 664                         devc->cur_mqflags = SR_MQFLAG_MAX;
 665                 else if (devc->token == TOKEN_HOLD_MIN)
 666                         devc->cur_mqflags = SR_MQFLAG_MIN;
 667         }
 668         *holdmode = devc->cur_mqflags & (SR_MQFLAG_MAX | SR_MQFLAG_MIN);
 669
 670         return SR_OK;
 671 }
 672
 673 SR_PRIV int cem_dt_885x_holdmode_set(const struct sr_dev_inst *sdi, int holdmode)
 674 {
 675         struct dev_context *devc;
 676         int cur_setting, ret;
 677         int8_t tokens[5];
 678
 679         devc = sdi->priv;
 680
 681         /* The toggle below needs the desired state in first position. */
 682         if (holdmode == SR_MQFLAG_MAX) {
 683                 tokens[0] = TOKEN_HOLD_MAX;
 684                 tokens[1] = TOKEN_HOLD_MIN;
 685                 tokens[2] = TOKEN_HOLD_NONE;
 686         } else if (holdmode == SR_MQFLAG_MIN) {
 687                 tokens[0] = TOKEN_HOLD_MIN;
 688                 tokens[1] = TOKEN_HOLD_MAX;
 689                 tokens[2] = TOKEN_HOLD_NONE;
 690         } else {
 691                 tokens[0] = TOKEN_HOLD_NONE;
 692                 tokens[1] = TOKEN_HOLD_MAX;
 693                 tokens[2] = TOKEN_HOLD_MIN;
 694         }
 695         tokens[3] = -1;
 696
 697         if (devc->cur_mqflags == 0) {
 698                 /* Didn't pick up device state yet. */
 699                 if (wait_for_token(sdi, tokens, 0) != SR_OK)
 700                         return SR_ERR;
 701                 if (devc->token == tokens[0])
 702                         /* Nothing to do. */
 703                         return SR_OK;
 704         } else {
 705                 cur_setting = devc->cur_mqflags & (SR_MQFLAG_MAX | SR_MQFLAG_MIN);
 706                 if (cur_setting == holdmode)
 707                         /* Already set correctly. */
 708                         return SR_OK;
 709         }
 710
 711         /* 51ms timeout seems to work best for this. */
 712         ret = cem_dt_885x_toggle(sdi, CMD_TOGGLE_HOLD_MAX_MIN, tokens, 51);
 713
 714         return ret;
 715 }
 716
 717 SR_PRIV int cem_dt_885x_meas_range_get(const struct sr_dev_inst *sdi,
 718                 uint64_t *low, uint64_t *high)
 719 {
 720         struct dev_context *devc;
 721         int8_t tokens[5];
 722
 723         devc = sdi->priv;
 724         if (devc->cur_meas_range == 0) {
 725                 tokens[0] = TOKEN_MEAS_RANGE_30_130;
 726                 tokens[1] = TOKEN_MEAS_RANGE_30_80;
 727                 tokens[2] = TOKEN_MEAS_RANGE_50_100;
 728                 tokens[3] = TOKEN_MEAS_RANGE_80_130;
 729                 tokens[4] = -1;
 730                 if (wait_for_token(sdi, tokens, 0) != SR_OK)
 731                         return SR_ERR;
 732                 devc->cur_meas_range = devc->token;
 733         }
 734
 735         switch (devc->cur_meas_range) {
 736         case TOKEN_MEAS_RANGE_30_130:
 737                 *low = 30;
 738                 *high = 130;
 739                 break;
 740         case TOKEN_MEAS_RANGE_30_80:
 741                 *low = 30;
 742                 *high = 80;
 743                 break;
 744         case TOKEN_MEAS_RANGE_50_100:
 745                 *low = 50;
 746                 *high = 100;
 747                 break;
 748         case TOKEN_MEAS_RANGE_80_130:
 749                 *low = 80;
 750                 *high = 130;
 751                 break;
 752         default:
 753                 return SR_ERR;
 754         }
 755
 756         return SR_OK;
 757 }
 758
 759 SR_PRIV int cem_dt_885x_meas_range_set(const struct sr_dev_inst *sdi,
 760                 uint64_t low, uint64_t high)
 761 {
 762         struct dev_context *devc;
 763         int ret;
 764         int8_t token, tokens[6];
 765
 766         devc = sdi->priv;
 767         if (low == 30 && high == 130)
 768                 token = TOKEN_MEAS_RANGE_30_130;
 769         else if (low == 30 &&  high == 80)
 770                 token = TOKEN_MEAS_RANGE_30_80;
 771         else if (low == 50 &&  high == 100)
 772                 token = TOKEN_MEAS_RANGE_50_100;
 773         else if (low == 80 &&  high == 130)
 774                 token = TOKEN_MEAS_RANGE_80_130;
 775         else
 776                 return SR_ERR;
 777
 778         sr_dbg("want 0x%.2x", token);
 779         /* The toggle below needs the desired state in first position. */
 780         tokens[0] = token;
 781         tokens[1] = TOKEN_MEAS_RANGE_30_130;
 782         tokens[2] = TOKEN_MEAS_RANGE_30_80;
 783         tokens[3] = TOKEN_MEAS_RANGE_50_100;
 784         tokens[4] = TOKEN_MEAS_RANGE_80_130;
 785         tokens[5] = -1;
 786
 787         if (devc->cur_meas_range == 0) {
 788                 /* 110ms should be enough for two of these announcements */
 789                 if (wait_for_token(sdi, tokens, 110) != SR_OK)
 790                         return SR_ERR;
 791                 devc->cur_meas_range = devc->token;
 792         }
 793
 794         if (devc->cur_meas_range == token)
 795                 /* Already set to this range. */
 796                 return SR_OK;
 797
 798         /* For measurement range, it works best to ignore announcements of the
 799          * current setting and keep resending the toggle quickly. */
 800         tokens[1] = -1;
 801         ret = cem_dt_885x_toggle(sdi, CMD_TOGGLE_MEAS_RANGE, tokens, 11);
 802
 803         return ret;
 804 }
 805
 806 SR_PRIV int cem_dt_885x_power_off(const struct sr_dev_inst *sdi)
 807 {
 808         struct sr_serial_dev_inst *serial;
 809         char c, cmd;
 810
 811         serial = sdi->conn;
 812
 813         cmd = CMD_TOGGLE_POWER_OFF;
 814         while (TRUE) {
 815                 serial_flush(serial);
 816                 if (serial_write_nonblocking(serial, (const void *)&cmd, 1) != 1)
 817                         return SR_ERR;
 818                 /* It never takes more than 23ms for the next token to arrive. */
 819                 g_usleep(25 * 1000);
 820                 if (serial_read_nonblocking(serial, &c, 1) != 1)
 821                         /* Device is no longer responding. Good! */
 822                         break;
 823         }
 824
 825         /* In case the user manually turns on the device again, reset
 826          * the port back to blocking. */
 827         serial_close(serial);
 828         serial_open(serial, SERIAL_RDWR);
 829
 830         return SR_OK;
 831 }