dmm/bm52x: silence overzealous compiler warning

[libsigrok.git] / src / lcr / vc4080.c

/*
 * This file is part of the libsigrok project.
 *
 * Copyright (C) 2019 Gerhard Sittig <gerhard.sittig@gmx.net>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <config.h>
#include <glib.h>
#include <libsigrok/libsigrok.h>
#include "libsigrok-internal.h"
#include <math.h>
#include <stdint.h>
#include <string.h>

#define LOG_PREFIX "vc4080"

#ifdef HAVE_SERIAL_COMM

/**
 * @file Packet parser for Voltcraft 4080 LCR meters.
 */

/*
 * Developer notes on the protocol and the implementation:
 *
 * The LCR meter is connected to a serial port (1200/7e1). The protocol
 * is text based (printables plus some line termination), is accessible
 * to interactive exploration in a terminal. Requests differ in length
 * (single character, or sequence of seven characters in brackets).
 * Responses either have 14 (setup) or 39 (measurement) characters.
 * Thus the protocol lends itself to integration with the serial-lcr
 * driver. Setup is handled outside of the acquisition loop, and all
 * measurement results are of equal length and end in a termination
 * that we can synchronize to. Requesting packets from the meter is
 * similar to serial-dmm operation.
 *
 * Quick notes for our parser's purposes:
 *
 *   pkt[0] 'L'/'C'/'R'
 *   pkt[1] 'Q'/'D'/'R'
 *   pkt[2] 'A'/'B' output frequency
 *   pkt[3] 'P'/'S' circuit model
 *   pkt[4] 'A'/'M' auto/manual
 *
 *   pkt[5:9] main display value in text format, '8' switching range, '9' OL
 *   pkt[10] main display range, '0'-'6', depends on RLC and freq and ser/par
 *
 *   pkt[11:14] secondary display value in text format, '9' OL
 *   pkt[15] secondary display range, '1'-'5', depends on QDR and Rs value
 *
 *   pkt[16] packet sequence counter, cycling through '0'-'9'
 *
 *   pkt[17:20] D value in text form, '9' OL
 *   pkt[21] D range
 *
 *   pkt[22:25] Q value in text form, '9' OL
 *   pkt[26] Q range
 *
 *   pkt[27] 'S'/'_', SETup(?)
 *   pkt[28] 'F'/'_', FUSE
 *   pkt[29] 'H'/'_', HOLD
 *   pkt[30] 'R' (present value), 'M' (max), 'I' (min), 'A' (avg),
 *           'X' (max - min), '_' (normal)
 *   pkt[31] 'R' (REL), 'S' (REL SET), '_' (normal)
 *   pkt[32] 'L' (LIMITS), '_' (normal)
 *   pkt[33] 'T' (TOL), 'S' (TOL SET), '_' (normal)
 *   pkt[34] 'B' (backlight), '_' (normal)
 *   pkt[35] 'A' (adapter inserted(?)), '_' (normal)
 *   pkt[36] 'B' (low battery), '_' (normal)
 *
 *   pkt[37] always CR (\r)
 *   pkt[38] always LF (\n)
 *
 * Example packet, PeakTech 2165, 1200/8n1 and parity bit stripped:
 *
 *   L Q A P A 9 0 0 0 0 6 1 4 0 6 2 1 0 7 1 1 4 1 4 0 6 2 _ _ _ _ _ _ _ _ _ _ CR LF
 *   0         5         10        15        20        25        30        35     38
 *
 * Another example, resistance mode, 1k probed:
 *
 *   52 5f 42 5f 41 30 39 39 33 30 32 30 30 30 30 39 33 37 34 35 36 31 30 30 31 33 34 5f 5f 5f 5f 5f 5f 5f 5f 5f 5f 0d 0a
 *   R _ B _ A 09930 2 00009 3 7456 1 0013 4 __________  CR/LF
 *
 * Another example, C mode:
 *
 *   43 51 42 53 4d 30 39 38 39 31 35 30 30 31 33 34 31 37 35 38 33 31 30 30 31 33 34 5f 5f 5f 5f 5f 5f 5f 5f 5f 5f 0d 0a
 *   C  Q  B  S  M  09891 5           00134 1           7583 1         0013 4         ____...
 *   C, Q, 120, ser, man, 09891 @2000uF -> C = 989.1uF, 00134 -> Q = 13.4
 *
 *   43 51 42 53 4d 30 39 38 38 30 35 30 30 31 33 34 34 37 35 37 34 31 30 30 31 33 34 5f 5f 5f 5f 5f 5f 5f 42 5f 5f 0d 0a
 *   900uF (main)
 *
 * For more details see Conrad's summary document and PeakTech's manual:
 * http://www.produktinfo.conrad.com/datenblaetter/100000-124999/121064-da-01-en-Schnittstellenbeschr_LCR_4080_Handmessg.pdf
 * http://peaktech.de/productdetail/kategorie/lcr-messer/produkt/p-2165.html?file=tl_files/downloads/2001%20-%203000/PeakTech_2165_USB.pdf
 *
 * TODO
 * - Check response lengths. Are line terminators involved during setup?
 * - Check parity. Does FT232R not handle parity correctly? Neither 7e1 (as
 *   documented) nor 7o1 (for fun) worked. 8n1 provided data but contained
 *   garbage (LCR driver needs to strip off the parity bit?).
 * - Determine whether the D and Q channels are required. It seems that
 *   every LCR packet has space to provide these values, but we may as well
 *   get away with just two channels, since users can select D and Q to be
 *   shown in the secondary display. It's yet uncertain whether the D and Q
 *   values in the packets are meaningful when the meter is not in the D/Q
 *   measurement mode.
 */

/*
 * Supported output frequencies and equivalent circuit models. A helper
 * for the packet parser (accepting a "code" for the property, regardless
 * of its position in the LCR packet), and a list for capability queries.
 * Concentrated in a single spot to remain aware duing maintenance.
 */

static const double frequencies[] = {
	SR_HZ(120), SR_KHZ(1),
};

static uint64_t get_frequency(char code)
{
	switch (code) {
	case 'A': return SR_KHZ(1);
	case 'B': return SR_HZ(120);
	default: return 0;
	}
}

enum equiv_model { MODEL_PAR, MODEL_SER, MODEL_NONE, };

static const char *const circuit_models[] = {
	"PARALLEL", "SERIES", "NONE",
};

static enum equiv_model get_equiv_model(char lcr_code, char model_code)
{
	switch (lcr_code) {
	case 'L': /* EMPTY */ break;
	case 'C': /* EMPTY */ break;
	case 'R': return MODEL_NONE;
	default: return MODEL_NONE;
	}
	switch (model_code) {
	case 'P': return MODEL_PAR;
	case 'S': return MODEL_SER;
	default: return MODEL_NONE;
	}
}

static const char *get_equiv_model_text(enum equiv_model model)
{
	return circuit_models[model];
}

/*
 * Packet parse routine and its helpers. Depending on the specific layout
 * of the meter's packet which communicates measurement results. Some of
 * them are also used outside of strict packet parsing for value extraction.
 */

static uint64_t parse_freq(const uint8_t *pkt)
{
	return get_frequency(pkt[2]);
}

static const char *parse_model(const uint8_t *pkt)
{
	return get_equiv_model_text(get_equiv_model(pkt[0], pkt[3]));
}

static float parse_number(const uint8_t *digits, size_t length)
{
	char value_text[8];
	float number;
	int ret;

	memcpy(value_text, digits, length);
	value_text[length] = '\0';
	ret = sr_atof_ascii(value_text, &number);

	return (ret == SR_OK) ? number : 0;
}

/*
 * Conrad's protocol description suggests that:
 * - The main display's LCR selection, output frequency, and range
 *   result in an Rs value in the 100R to 100k range, in addition to
 *   the main display's scale for the value.
 * - The secondary display's DQR selection, the above determined Rs
 *   value, and range result in the value's scale.
 * - The D and Q values' range seems to follow the secondary display's
 *   logic.
 */

enum lcr_kind { LCR_NONE, LCR_IS_L, LCR_IS_C, LCR_IS_R, };
enum dqr_kind { DQR_NONE, DQR_IS_D, DQR_IS_Q, DQR_IS_R, };

static int get_main_scale_rs(int *digits, int *rs,
	uint8_t range, enum lcr_kind lcr, uint64_t freq)
{
	/*
	 * Scaling factors for values. Digits count for 20000 full scale.
	 * Full scale values for different modes are:
	 *   R: 20R, 200R, 2k, 20k, 200k, 2M, 10M
	 *   L 1kHz: 2mH, 20mH, 200mH, 2H, 20H, 200H, 1000H
	 *   L 120Hz: 20mH, 200mH, 2H, 20H, 200H, 2kH, 10kH
	 *   C 1kHz: 2nF, 20nF, 200nF, 2uF, 20uF, 200uF, 2mF
	 *   C 120Hz: 20nF, 200nF, 2unF, 20uF, 200uF, 2muF, 20mF
	 */
	static const int dig_r[] = { -3, -2, -1, +0, +1, +2, +3, };
	static const int dig_l_1k[] = { -7, -6, -5, -4, -3, -2, -1, };
	static const int dig_l_120[] = { -6, -5, -4, -3, -2, -1, 0, };
	static const int dig_c_1k[] = { -13, -12, -11, -10, -9, -8, -7, };
	static const int dig_c_120[] = { -12, -11, -10, -9, -8, -7, -6, };
	/*
	 * Rs values for the scale, depending on LCR mode.
	 * Values for R/L: 100R, 100R, 100R, 1k, 10k, 100k, 100k
	 * Values for C: 100k, 100k, 10k, 1k, 100R, 100R, 100R
	 */
	static const int rs_r_l[] = {
		100, 100, 100, 1000, 10000, 100000, 100000,
	};
	static const int rs_c[] = {
		100000, 100000, 10000, 1000, 100, 100, 100,
	};

	const int *digits_table, *rs_table;

	/* The 'range' input value is only valid between 0..6. */
	if (range > 6)
		return SR_ERR_DATA;

	if (lcr == LCR_IS_R) {
		digits_table = dig_r;
		rs_table = rs_r_l;
	} else if (lcr == LCR_IS_L && freq == SR_KHZ(1)) {
		digits_table = dig_l_1k;
		rs_table = rs_r_l;
	} else if (lcr == LCR_IS_L && freq == SR_HZ(120)) {
		digits_table = dig_l_120;
		rs_table = rs_r_l;
	} else if (lcr == LCR_IS_C && freq == SR_KHZ(1)) {
		digits_table = dig_c_1k;
		rs_table = rs_c;
	} else if (lcr == LCR_IS_C && freq == SR_HZ(120)) {
		digits_table = dig_c_120;
		rs_table = rs_c;
	} else {
		return SR_ERR_DATA;
	}

	if (digits)
		*digits = digits_table[range];
	if (rs)
		*rs = rs_table[range];

	return SR_OK;
}

static int get_sec_scale(int *digits, uint8_t range, enum dqr_kind dqr, int rs)
{
	static const int dig_d_q[] = { 0, -1, -2, -3, -4, 0, };
	static const int dig_r_100[] = { 0, -2, -1, +0, +1, 0, };
	static const int dig_r_1k_10k[] = { 0, -2, -1, +0, +1, +2, };
	static const int dig_r_100k[] = { 0, 0, -1, +0, +1, +2, };

	const int *digits_table;

	/*
	 * Absolute 'range' limits are 1..5, some modes have additional
	 * invalid positions (these get checked below).
	 */
	if (range < 1 || range > 5)
		return SR_ERR_DATA;

	if (dqr == DQR_IS_D || dqr == DQR_IS_Q) {
		if (range > 4)
			return SR_ERR_DATA;
		digits_table = dig_d_q;
	} else if (dqr == DQR_IS_R && rs == 100) {
		if (range > 4)
			return SR_ERR_DATA;
		digits_table = dig_r_100;
	} else if (dqr == DQR_IS_R && (rs == 1000 || rs == 10000)) {
		digits_table = dig_r_1k_10k;
	} else if (dqr == DQR_IS_R && rs == 100000) {
		if (range < 2)
			return SR_ERR_DATA;
		digits_table = dig_r_100k;
	} else {
		return SR_ERR_DATA;
	}

	if (digits)
		*digits = digits_table[range];

	return SR_OK;
}

static void parse_measurement(const uint8_t *pkt, float *floatval,
	struct sr_datafeed_analog *analog, size_t disp_idx)
{
	enum lcr_kind lcr;
	enum dqr_kind dqr;
	uint64_t freq;
	enum equiv_model model;
	gboolean is_auto, main_ranging, main_ol, sec_ol, d_ol, q_ol;
	float main_value, sec_value, d_value, q_value;
	char main_range, sec_range, d_range, q_range;
	gboolean is_hold, is_relative, has_adapter, is_lowbatt;
	enum minmax_kind {
		MINMAX_MAX, MINMAX_MIN, MINMAX_SPAN,
		MINMAX_AVG, MINMAX_CURR, MINMAX_NONE,
	} minmax;
	gboolean is_parallel;
	int mq, mqflags, unit;
	float value;
	int digits, exponent;
	gboolean ol, invalid;
	int ret, rs, main_digits, sec_digits, d_digits, q_digits;
	int main_invalid, sec_invalid, d_invalid, q_invalid;

	/* Prepare void return values for error paths. */
	analog->meaning->mq = 0;
	analog->meaning->mqflags = 0;
	if (disp_idx >= VC4080_CHANNEL_COUNT)
		return;

	/*
	 * The interpretation of secondary displays may depend not only
	 * on the meter's status (indicator flags), but also on the main
	 * display's current value (ranges, scaling). Unconditionally
	 * inspect most of the packet's content, regardless of which
	 * display we are supposed to extract the value for in this
	 * invocation.
	 *
	 * While we are converting the input text, check a few "fatal"
	 * conditions early, cease further packet inspection when the
	 * value is unstable or not yet available, or when the meter's
	 * current mode/function is not supported by this LCR parser.
	 */
	switch (pkt[0]) {
	case 'L': lcr = LCR_IS_L; break;
	case 'R': lcr = LCR_IS_R; break;
	case 'C': lcr = LCR_IS_C; break;
	default: return;
	}
	switch (pkt[1]) {
	case 'D': dqr = DQR_IS_D; break;
	case 'Q': dqr = DQR_IS_Q; break;
	case 'R': dqr = DQR_IS_R; break;
	case '_': dqr = DQR_NONE; break; /* Can be valid, like in R mode. */
	default: return;
	}
	freq = get_frequency(pkt[2]);
	model = get_equiv_model(pkt[0], pkt[3]);
	is_auto = pkt[4] == 'A';
	main_ranging = pkt[5] == '8';
	if (main_ranging)	/* Switching ranges. */
		return;
	main_ol = pkt[5] == '9';
	main_value = parse_number(&pkt[5], 5);
	main_range = pkt[10];
	if (main_range < '0' || main_range > '6')
		main_range = '9';
	main_range -= '0';
	/*
	 * Contrary to the documentation, there have been valid four-digit
	 * values in the secondary display which start with '9'. Let's not
	 * consider these as overflown. Out-of-range 'range' specs for the
	 * secondary display will also invalidate these values.
	 */
	sec_ol = 0 && pkt[11] == '9';
	sec_value = parse_number(&pkt[11], 4);
	sec_range = pkt[15];
	if (sec_range < '0' || sec_range > '6')
		sec_range = '9';
	sec_range -= '0';
	d_ol = pkt[17] == '9';
	d_value = parse_number(&pkt[17], 4);
	d_range = pkt[21];
	if (d_range < '0' || d_range > '6')
		d_range = '9';
	d_range -= '0';
	q_ol = pkt[22] == '9';
	q_value = parse_number(&pkt[22], 4);
	q_range = pkt[26];
	if (q_range < '0' || q_range > '6')
		q_range = '9';
	d_range -= '0';
	switch (pkt[27]) {
	case 'S': return;	/* Setup mode. Not supported. */
	case '_': /* EMPTY */ break;
	default: return;	/* Unknown. */
	}
	is_hold = pkt[29] == 'H';
	switch (pkt[30]) {	/* Min/max modes. */
	case 'R': minmax = MINMAX_CURR; break;	/* Live reading. */
	case 'M': minmax = MINMAX_MAX; break;
	case 'I': minmax = MINMAX_MIN; break;
	case 'X': minmax = MINMAX_SPAN; break;	/* "Max - min" difference. */
	case 'A': minmax = MINMAX_AVG; break;
	case '_': minmax = MINMAX_NONE; break;
	default: return;	/* Unknown. */
	}
	if (minmax == MINMAX_SPAN)	/* Not supported. */
		return;
	if (minmax == MINMAX_CURR)	/* Normalize. */
		minmax = MINMAX_NONE;
	switch (pkt[31]) {
	case 'R': is_relative = TRUE; break;
	case 'S': return;	/* Relative setup. Not supported. */
				/* TODO Is this SR_MQFLAG_REFERENCE? */
	case '_': is_relative = FALSE; break;
	default: return;	/* Unknown. */
	}
	if (pkt[32] != '_')	/* Limits. Not supported. */
		return;
	if (pkt[33] != '_')	/* Tolerance. Not supported. */
		return;
	has_adapter = pkt[35] == 'A';
	is_lowbatt = pkt[36] == 'B';

	/*
	 * Always need to inspect the main display's properties, to
	 * determine how to interpret the secondary displays.
	 */
	rs = main_digits = sec_digits = d_digits = q_digits = 0;
	main_invalid = sec_invalid = d_invalid = q_invalid = 0;
	ret = get_main_scale_rs(&main_digits, &rs, main_range, lcr, freq);
	if (ret != SR_OK)
		main_invalid = 1;
	ret = get_sec_scale(&sec_digits, sec_range, dqr, rs);
	if (ret != SR_OK)
		sec_invalid = 1;
	ret = get_sec_scale(&d_digits, d_range, dqr, rs);
	if (ret != SR_OK)
		d_invalid = 1;
	ret = get_sec_scale(&q_digits, q_range, dqr, rs);
	if (ret != SR_OK)
		q_invalid = 1;

	/* Determine the measurement value and its units. Apply scaling. */
	is_parallel = model == MODEL_PAR;
	mq = 0;
	mqflags = 0;
	unit = 0;
	switch (disp_idx) {
	case VC4080_DISPLAY_PRIMARY:
		invalid = main_invalid;
		if (invalid)
			break;
		if (lcr == LCR_IS_L) {
			mq = is_parallel
				? SR_MQ_PARALLEL_INDUCTANCE
				: SR_MQ_SERIES_INDUCTANCE;
			unit = SR_UNIT_HENRY;
		} else if (lcr == LCR_IS_C) {
			mq = is_parallel
				? SR_MQ_PARALLEL_CAPACITANCE
				: SR_MQ_SERIES_CAPACITANCE;
			unit = SR_UNIT_FARAD;
		} else if (lcr == LCR_IS_R) {
			mq = is_parallel
				? SR_MQ_PARALLEL_RESISTANCE
				: SR_MQ_SERIES_RESISTANCE;
			unit = SR_UNIT_OHM;
		}
		value = main_value;
		ol = main_ol;
		digits = 0;
		exponent = main_digits;
		break;
	case VC4080_DISPLAY_SECONDARY:
		invalid = sec_invalid;
		if (invalid)
			break;
		if (dqr == DQR_IS_D) {
			mq = SR_MQ_DISSIPATION_FACTOR;
			unit = SR_UNIT_UNITLESS;
		} else if (dqr == DQR_IS_Q) {
			mq = SR_MQ_QUALITY_FACTOR;
			unit = SR_UNIT_UNITLESS;
		} else if (dqr == DQR_IS_R) {
			mq = SR_MQ_RESISTANCE;
			unit = SR_UNIT_OHM;
		}
		value = sec_value;
		ol = sec_ol;
		digits = 0;
		exponent = sec_digits;
		break;
#if VC4080_WITH_DQ_CHANS
	case VC4080_DISPLAY_D_VALUE:
		invalid = d_invalid;
		if (invalid)
			break;
		mq = SR_MQ_DISSIPATION_FACTOR;
		unit = SR_UNIT_UNITLESS;
		value = d_value;
		ol = d_ol;
		digits = 4;
		exponent = d_digits;
		break;
	case VC4080_DISPLAY_Q_VALUE:
		invalid = q_invalid;
		if (invalid)
			break;
		mq = SR_MQ_QUALITY_FACTOR;
		unit = SR_UNIT_UNITLESS;
		value = q_value;
		ol = q_ol;
		digits = 4;
		exponent = q_digits;
		break;
#else
	(void)d_invalid;
	(void)d_value;
	(void)d_ol;
	(void)d_digits;
	(void)q_invalid;
	(void)q_value;
	(void)q_ol;
	(void)q_digits;
#endif
	default:
		/* ShouldNotHappen(TM). Won't harm either. Silences warnings. */
		return;
	}
	if (invalid)
		return;
	if (is_auto)
		mqflags |= SR_MQFLAG_AUTORANGE;
	if (is_hold)
		mqflags |= SR_MQFLAG_HOLD;
	if (is_relative)
		mqflags |= SR_MQFLAG_RELATIVE;
	if (has_adapter)
		mqflags |= SR_MQFLAG_FOUR_WIRE;
	switch (minmax) {
	case MINMAX_MAX:
		mqflags |= SR_MQFLAG_MAX;
		break;
	case MINMAX_MIN:
		mqflags |= SR_MQFLAG_MIN;
		break;
	case MINMAX_SPAN:
		mqflags |= SR_MQFLAG_MAX | SR_MQFLAG_RELATIVE;
		break;
	case MINMAX_AVG:
		mqflags |= SR_MQFLAG_AVG;
		break;
	case MINMAX_CURR:
	case MINMAX_NONE:
	default:
		/* EMPTY */
		break;
	}

	/* "Commit" the resulting value. */
	if (ol) {
		value = INFINITY;
	} else {
		value *= powf(10, exponent);
		digits -= exponent;
	}
	*floatval = value;
	analog->meaning->mq = mq;
	analog->meaning->mqflags = mqflags;
	analog->meaning->unit = unit;
	analog->encoding->digits = digits;
	analog->spec->spec_digits = digits;

	/* Low battery is rather severe, the measurement could be invalid. */
	if (is_lowbatt)
		sr_warn("Low battery.");
}

/*
 * Workaround for cables' improper(?) parity handling.
 * TODO Should this move to serial-lcr or even common libsigrok code?
 *
 * Implementor's note: Serial communication is documented to be 1200/7e1.
 * But practial setups with the shipped FT232R cable received no response
 * at all with these settings. The 8n1 configuration resulted in responses
 * while the LCR meter's packet parser then needs to strip the parity bits.
 *
 * Let's run this slightly modified setup for now, until more cables and
 * compatible devices got observed and the proper solution gets determined.
 * This cheat lets us receive measurement data right now. Stripping the
 * parity bits off the packet bytes here in the parser is an idempotent
 * operation that happens to work during stream detect as well as in the
 * acquisition loop. It helps in the 8n1 configuration, and keeps working
 * transparently in the 7e1 configuration, too. No harm is done, and the
 * initial device support is achieved.
 *
 * By coincidence, the 'N' command which requests the next measurement
 * value happens to conform with the 7e1 frame format (0b_0100_1110
 * byte value). When the SETUP commands are supposed to work with this
 * LCR meter as well, then the serial-lcr driver's TX data and RX data
 * probably needs to pass LCR chip specific transformation routines,
 * if the above mentioned parity support in serial cables issue has not
 * yet been resolved.
 */

static void strip_parity_bit(uint8_t *p, size_t l)
{
	while (l--)
		*p++ &= ~0x80;
}

/* LCR packet parser's public API. */

SR_PRIV const char *vc4080_channel_formats[VC4080_CHANNEL_COUNT] = {
	"P1", "P2",
#if VC4080_WITH_DQ_CHANS
	"D", "Q",
#endif
};

SR_PRIV int vc4080_packet_request(struct sr_serial_dev_inst *serial)
{
	static const char *command = "N";

	serial_write_blocking(serial, command, strlen(command), 0);

	return SR_OK;
}

SR_PRIV gboolean vc4080_packet_valid(const uint8_t *pkt)
{
	/* Workaround for funny serial cables. */
	strip_parity_bit((void *)pkt, VC4080_PACKET_SIZE);

	/* Fixed CR/LF terminator. */
	if (pkt[37] != '\r' || pkt[38] != '\n')
		return FALSE;

	return TRUE;
}

SR_PRIV int vc4080_packet_parse(const uint8_t *pkt, float *val,
	struct sr_datafeed_analog *analog, void *info)
{
	struct lcr_parse_info *parse_info;

	/* Workaround for funny serial cables. */
	strip_parity_bit((void *)pkt, VC4080_PACKET_SIZE);

	parse_info = info;
	if (!parse_info->ch_idx) {
		parse_info->output_freq = parse_freq(pkt);
		parse_info->circuit_model = parse_model(pkt);
	}
	if (val && analog)
		parse_measurement(pkt, val, analog, parse_info->ch_idx);

	return SR_OK;
}

/*
 * These are the get/set/list routines for the _chip_ specific parameters,
 * the _device_ driver resides in src/hardware/serial-lcr/ instead.
 */

SR_PRIV int vc4080_config_list(uint32_t key, GVariant **data,
	const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
{

	(void)sdi;
	(void)cg;

	switch (key) {
	case SR_CONF_OUTPUT_FREQUENCY:
		*data = g_variant_new_fixed_array(G_VARIANT_TYPE_DOUBLE,
			ARRAY_AND_SIZE(frequencies), sizeof(frequencies[0]));
		return SR_OK;
	case SR_CONF_EQUIV_CIRCUIT_MODEL:
		*data = g_variant_new_strv(ARRAY_AND_SIZE(circuit_models));
		return SR_OK;
	default:
		return SR_ERR_NA;
	}
	/* UNREACH */
}

#endif