X-Git-Url: https://sigrok.org/gitweb/?p=libsigrok.git;a=blobdiff_plain;f=src%2Flibsigrok-internal.h;h=0d18bee44d1fe7a184f094ff1a9fd5f821064dc5;hp=f5dde75a96c68d3c24fc9a7211d93e9d90754c2f;hb=HEAD;hpb=7d1a4a52392a048c24ec25459f462a0126c9ad2c diff --git a/src/libsigrok-internal.h b/src/libsigrok-internal.h index f5dde75a..68a45f27 100644 --- a/src/libsigrok-internal.h +++ b/src/libsigrok-internal.h @@ -17,24 +17,28 @@ * along with this program. If not, see . */ -/** - * @file - * - * @internal - */ - #ifndef LIBSIGROK_LIBSIGROK_INTERNAL_H #define LIBSIGROK_LIBSIGROK_INTERNAL_H -#include -#include +#include "config.h" + #include -#ifdef HAVE_LIBUSB_1_0 -#include +#ifdef HAVE_LIBHIDAPI +#include #endif #ifdef HAVE_LIBSERIALPORT #include #endif +#ifdef HAVE_LIBUSB_1_0 +#include +#endif +#ifdef HAVE_LIBFTDI +#include +#endif +#include +#include +#include +#include struct zip; struct zip_stat; @@ -55,202 +59,1041 @@ struct zip_stat; #define ARRAY_AND_SIZE(a) (a), ARRAY_SIZE(a) #endif +#ifndef G_SOURCE_FUNC +#define G_SOURCE_FUNC(f) ((GSourceFunc) (void (*)(void)) (f)) /* Since 2.58. */ +#endif + +#define SR_RECEIVE_DATA_CALLBACK(f) \ + ((sr_receive_data_callback) (void (*)(void)) (f)) + /** * Read a 8 bits unsigned integer out of memory. * @param x a pointer to the input memory * @return the corresponding unsigned integer */ -#define R8(x) ((unsigned)((const uint8_t*)(x))[0]) +static inline uint8_t read_u8(const uint8_t *p) +{ + return p[0]; +} +#define R8(x) read_u8((const uint8_t *)(x)) + +/** + * Read an 8 bits signed integer out of memory. + * @param x a pointer to the input memory + * @return the corresponding signed integer + */ +static inline int8_t read_i8(const uint8_t *p) +{ + return (int8_t)p[0]; +} /** * Read a 16 bits big endian unsigned integer out of memory. * @param x a pointer to the input memory * @return the corresponding unsigned integer */ -#define RB16(x) (((unsigned)((const uint8_t*)(x))[0] << 8) | \ - (unsigned)((const uint8_t*)(x))[1]) +static inline uint16_t read_u16be(const uint8_t *p) +{ + uint16_t u; + + u = 0; + u <<= 8; u |= p[0]; + u <<= 8; u |= p[1]; + + return u; +} +#define RB16(x) read_u16be((const uint8_t *)(x)) /** * Read a 16 bits little endian unsigned integer out of memory. * @param x a pointer to the input memory * @return the corresponding unsigned integer */ -#define RL16(x) (((unsigned)((const uint8_t*)(x))[1] << 8) | \ - (unsigned)((const uint8_t*)(x))[0]) +static inline uint16_t read_u16le(const uint8_t *p) +{ + uint16_t u; + + u = 0; + u <<= 8; u |= p[1]; + u <<= 8; u |= p[0]; + + return u; +} +#define RL16(x) read_u16le((const uint8_t *)(x)) /** * Read a 16 bits big endian signed integer out of memory. * @param x a pointer to the input memory * @return the corresponding signed integer */ -#define RB16S(x) ((int16_t) \ - (((unsigned)((const uint8_t*)(x))[0] << 8) | \ - (unsigned)((const uint8_t*)(x))[1])) +static inline int16_t read_i16be(const uint8_t *p) +{ + uint16_t u; + int16_t i; + + u = read_u16be(p); + i = (int16_t)u; + + return i; +} +#define RB16S(x) read_i16be((const uint8_t *)(x)) /** * Read a 16 bits little endian signed integer out of memory. * @param x a pointer to the input memory * @return the corresponding signed integer */ -#define RL16S(x) ((int16_t) \ - (((unsigned)((const uint8_t*)(x))[1] << 8) | \ - (unsigned)((const uint8_t*)(x))[0])) +static inline int16_t read_i16le(const uint8_t *p) +{ + uint16_t u; + int16_t i; + + u = read_u16le(p); + i = (int16_t)u; + + return i; +} +#define RL16S(x) read_i16le((const uint8_t *)(x)) + +/** + * Read a 24 bits little endian unsigned integer out of memory. + * @param x a pointer to the input memory + * @return the corresponding unsigned integer + */ +static inline uint32_t read_u24le(const uint8_t *p) +{ + uint32_t u; + + u = 0; + u <<= 8; u |= p[2]; + u <<= 8; u |= p[1]; + u <<= 8; u |= p[0]; + + return u; +} + +/** + * Read a 24 bits big endian unsigned integer out of memory. + * @param x a pointer to the input memory + * @return the corresponding unsigned integer + */ +static inline uint32_t read_u24be(const uint8_t *p) +{ + uint32_t u; + + u = 0; + u <<= 8; u |= p[0]; + u <<= 8; u |= p[1]; + u <<= 8; u |= p[2]; + + return u; +} /** * Read a 32 bits big endian unsigned integer out of memory. * @param x a pointer to the input memory * @return the corresponding unsigned integer */ -#define RB32(x) (((unsigned)((const uint8_t*)(x))[0] << 24) | \ - ((unsigned)((const uint8_t*)(x))[1] << 16) | \ - ((unsigned)((const uint8_t*)(x))[2] << 8) | \ - (unsigned)((const uint8_t*)(x))[3]) +static inline uint32_t read_u32be(const uint8_t *p) +{ + uint32_t u; + + u = 0; + u <<= 8; u |= p[0]; + u <<= 8; u |= p[1]; + u <<= 8; u |= p[2]; + u <<= 8; u |= p[3]; + + return u; +} +#define RB32(x) read_u32be((const uint8_t *)(x)) /** * Read a 32 bits little endian unsigned integer out of memory. * @param x a pointer to the input memory * @return the corresponding unsigned integer */ -#define RL32(x) (((unsigned)((const uint8_t*)(x))[3] << 24) | \ - ((unsigned)((const uint8_t*)(x))[2] << 16) | \ - ((unsigned)((const uint8_t*)(x))[1] << 8) | \ - (unsigned)((const uint8_t*)(x))[0]) +static inline uint32_t read_u32le(const uint8_t *p) +{ + uint32_t u; + + u = 0; + u <<= 8; u |= p[3]; + u <<= 8; u |= p[2]; + u <<= 8; u |= p[1]; + u <<= 8; u |= p[0]; + + return u; +} +#define RL32(x) read_u32le((const uint8_t *)(x)) /** * Read a 32 bits big endian signed integer out of memory. * @param x a pointer to the input memory * @return the corresponding signed integer */ -#define RB32S(x) ((int32_t) \ - (((unsigned)((const uint8_t*)(x))[0] << 24) | \ - ((unsigned)((const uint8_t*)(x))[1] << 16) | \ - ((unsigned)((const uint8_t*)(x))[2] << 8) | \ - (unsigned)((const uint8_t*)(x))[3])) +static inline int32_t read_i32be(const uint8_t *p) +{ + uint32_t u; + int32_t i; + + u = read_u32be(p); + i = (int32_t)u; + + return i; +} +#define RB32S(x) read_i32be((const uint8_t *)(x)) /** * Read a 32 bits little endian signed integer out of memory. * @param x a pointer to the input memory * @return the corresponding signed integer */ -#define RL32S(x) ((int32_t) \ - (((unsigned)((const uint8_t*)(x))[3] << 24) | \ - ((unsigned)((const uint8_t*)(x))[2] << 16) | \ - ((unsigned)((const uint8_t*)(x))[1] << 8) | \ - (unsigned)((const uint8_t*)(x))[0])) +static inline int32_t read_i32le(const uint8_t *p) +{ + uint32_t u; + int32_t i; + + u = read_u32le(p); + i = (int32_t)u; + + return i; +} +#define RL32S(x) read_i32le((const uint8_t *)(x)) /** * Read a 64 bits big endian unsigned integer out of memory. * @param x a pointer to the input memory * @return the corresponding unsigned integer */ -#define RB64(x) (((uint64_t)((const uint8_t*)(x))[0] << 56) | \ - ((uint64_t)((const uint8_t*)(x))[1] << 48) | \ - ((uint64_t)((const uint8_t*)(x))[2] << 40) | \ - ((uint64_t)((const uint8_t*)(x))[3] << 32) | \ - ((uint64_t)((const uint8_t*)(x))[4] << 24) | \ - ((uint64_t)((const uint8_t*)(x))[5] << 16) | \ - ((uint64_t)((const uint8_t*)(x))[6] << 8) | \ - (uint64_t)((const uint8_t*)(x))[7]) +static inline uint64_t read_u64be(const uint8_t *p) +{ + uint64_t u; + + u = 0; + u <<= 8; u |= p[0]; + u <<= 8; u |= p[1]; + u <<= 8; u |= p[2]; + u <<= 8; u |= p[3]; + u <<= 8; u |= p[4]; + u <<= 8; u |= p[5]; + u <<= 8; u |= p[6]; + u <<= 8; u |= p[7]; + + return u; +} +#define RB64(x) read_u64be((const uint8_t *)(x)) /** * Read a 64 bits little endian unsigned integer out of memory. * @param x a pointer to the input memory * @return the corresponding unsigned integer */ -#define RL64(x) (((uint64_t)((const uint8_t*)(x))[7] << 56) | \ - ((uint64_t)((const uint8_t*)(x))[6] << 48) | \ - ((uint64_t)((const uint8_t*)(x))[5] << 40) | \ - ((uint64_t)((const uint8_t*)(x))[4] << 32) | \ - ((uint64_t)((const uint8_t*)(x))[3] << 24) | \ - ((uint64_t)((const uint8_t*)(x))[2] << 16) | \ - ((uint64_t)((const uint8_t*)(x))[1] << 8) | \ - (uint64_t)((const uint8_t*)(x))[0]) +static inline uint64_t read_u64le(const uint8_t *p) +{ + uint64_t u; + + u = 0; + u <<= 8; u |= p[7]; + u <<= 8; u |= p[6]; + u <<= 8; u |= p[5]; + u <<= 8; u |= p[4]; + u <<= 8; u |= p[3]; + u <<= 8; u |= p[2]; + u <<= 8; u |= p[1]; + u <<= 8; u |= p[0]; + + return u; +} +#define RL64(x) read_u64le((const uint8_t *)(x)) + +/** + * Read a 64 bits big endian signed integer out of memory. + * @param x a pointer to the input memory + * @return the corresponding unsigned integer + */ +static inline int64_t read_i64be(const uint8_t *p) +{ + uint64_t u; + int64_t i; + + u = read_u64be(p); + i = (int64_t)u; + + return i; +} +#define RB64S(x) read_i64be((const uint8_t *)(x)) /** * Read a 64 bits little endian signed integer out of memory. * @param x a pointer to the input memory * @return the corresponding unsigned integer */ -#define RL64S(x) ((int64_t) \ - (((uint64_t)((const uint8_t*)(x))[7] << 56) | \ - ((uint64_t)((const uint8_t*)(x))[6] << 48) | \ - ((uint64_t)((const uint8_t*)(x))[5] << 40) | \ - ((uint64_t)((const uint8_t*)(x))[4] << 32) | \ - ((uint64_t)((const uint8_t*)(x))[3] << 24) | \ - ((uint64_t)((const uint8_t*)(x))[2] << 16) | \ - ((uint64_t)((const uint8_t*)(x))[1] << 8) | \ - (uint64_t)((const uint8_t*)(x))[0])) +static inline int64_t read_i64le(const uint8_t *p) +{ + uint64_t u; + int64_t i; + + u = read_u64le(p); + i = (int64_t)u; + + return i; +} +#define RL64S(x) read_i64le((const uint8_t *)(x)) /** - * Read a 32 bits big endian float out of memory. + * Read a 32 bits big endian float out of memory (single precision). * @param x a pointer to the input memory * @return the corresponding float */ -#define RBFL(x) ((union { uint32_t u; float f; }) { .u = RB32(x) }.f) +static inline float read_fltbe(const uint8_t *p) +{ + /* + * Implementor's note: Strictly speaking the "union" trick + * is not portable. But this phrase was found to work on the + * project's supported platforms, and serve well until a more + * appropriate phrase is found. + */ + union { uint32_t u32; float flt; } u; + float f; + + u.u32 = read_u32be(p); + f = u.flt; + + return f; +} +#define RBFL(x) read_fltbe((const uint8_t *)(x)) /** - * Read a 32 bits little endian float out of memory. + * Read a 32 bits little endian float out of memory (single precision). * @param x a pointer to the input memory * @return the corresponding float */ -#define RLFL(x) ((union { uint32_t u; float f; }) { .u = RL32(x) }.f) +static inline float read_fltle(const uint8_t *p) +{ + /* + * Implementor's note: Strictly speaking the "union" trick + * is not portable. But this phrase was found to work on the + * project's supported platforms, and serve well until a more + * appropriate phrase is found. + */ + union { uint32_t u32; float flt; } u; + float f; + + u.u32 = read_u32le(p); + f = u.flt; + + return f; +} +#define RLFL(x) read_fltle((const uint8_t *)(x)) + +/** + * Read a 64 bits big endian float out of memory (double precision). + * @param x a pointer to the input memory + * @return the corresponding floating point value + */ +static inline double read_dblbe(const uint8_t *p) +{ + /* + * Implementor's note: Strictly speaking the "union" trick + * is not portable. But this phrase was found to work on the + * project's supported platforms, and serve well until a more + * appropriate phrase is found. + */ + union { uint64_t u64; double flt; } u; + double f; + + u.u64 = read_u64be(p); + f = u.flt; + + return f; +} + +/** + * Read a 64 bits little endian float out of memory (double precision). + * @param x a pointer to the input memory + * @return the corresponding floating point value + */ +static inline double read_dblle(const uint8_t *p) +{ + /* + * Implementor's note: Strictly speaking the "union" trick + * is not portable. But this phrase was found to work on the + * project's supported platforms, and serve well until a more + * appropriate phrase is found. + */ + union { uint64_t u64; double flt; } u; + double f; + + u.u64 = read_u64le(p); + f = u.flt; + + return f; +} +#define RLDB(x) read_dblle((const uint8_t *)(x)) /** * Write a 8 bits unsigned integer to memory. * @param p a pointer to the output memory * @param x the input unsigned integer */ -#define W8(p, x) do { ((uint8_t*)(p))[0] = (uint8_t) (x); } while (0) +static inline void write_u8(uint8_t *p, uint8_t x) +{ + p[0] = x; +} +#define W8(p, x) write_u8((uint8_t *)(p), (uint8_t)(x)) /** * Write a 16 bits unsigned integer to memory stored as big endian. * @param p a pointer to the output memory * @param x the input unsigned integer */ -#define WB16(p, x) do { ((uint8_t*)(p))[1] = (uint8_t) (x); \ - ((uint8_t*)(p))[0] = (uint8_t)((x)>>8); } while (0) +static inline void write_u16be(uint8_t *p, uint16_t x) +{ + p[1] = x & 0xff; x >>= 8; + p[0] = x & 0xff; x >>= 8; +} +#define WB16(p, x) write_u16be((uint8_t *)(p), (uint16_t)(x)) /** * Write a 16 bits unsigned integer to memory stored as little endian. * @param p a pointer to the output memory * @param x the input unsigned integer */ -#define WL16(p, x) do { ((uint8_t*)(p))[0] = (uint8_t) (x); \ - ((uint8_t*)(p))[1] = (uint8_t)((x)>>8); } while (0) +static inline void write_u16le(uint8_t *p, uint16_t x) +{ + p[0] = x & 0xff; x >>= 8; + p[1] = x & 0xff; x >>= 8; +} +#define WL16(p, x) write_u16le((uint8_t *)(p), (uint16_t)(x)) + +/** + * Write a 24 bits unsigned integer to memory stored as little endian. + * @param p a pointer to the output memory + * @param x the input unsigned integer + */ +static inline void write_u24le(uint8_t *p, uint32_t x) +{ + p[0] = x & 0xff; x >>= 8; + p[1] = x & 0xff; x >>= 8; + p[2] = x & 0xff; x >>= 8; +} +#define WL24(p, x) write_u24le((uint8_t *)(p), (uint32_t)(x)) /** * Write a 32 bits unsigned integer to memory stored as big endian. * @param p a pointer to the output memory * @param x the input unsigned integer */ -#define WB32(p, x) do { ((uint8_t*)(p))[3] = (uint8_t) (x); \ - ((uint8_t*)(p))[2] = (uint8_t)((x)>>8); \ - ((uint8_t*)(p))[1] = (uint8_t)((x)>>16); \ - ((uint8_t*)(p))[0] = (uint8_t)((x)>>24); } while (0) +static inline void write_u32be(uint8_t *p, uint32_t x) +{ + p[3] = x & 0xff; x >>= 8; + p[2] = x & 0xff; x >>= 8; + p[1] = x & 0xff; x >>= 8; + p[0] = x & 0xff; x >>= 8; +} +#define WB32(p, x) write_u32be((uint8_t *)(p), (uint32_t)(x)) /** * Write a 32 bits unsigned integer to memory stored as little endian. * @param p a pointer to the output memory * @param x the input unsigned integer */ -#define WL32(p, x) do { ((uint8_t*)(p))[0] = (uint8_t) (x); \ - ((uint8_t*)(p))[1] = (uint8_t)((x)>>8); \ - ((uint8_t*)(p))[2] = (uint8_t)((x)>>16); \ - ((uint8_t*)(p))[3] = (uint8_t)((x)>>24); } while (0) +static inline void write_u32le(uint8_t *p, uint32_t x) +{ + p[0] = x & 0xff; x >>= 8; + p[1] = x & 0xff; x >>= 8; + p[2] = x & 0xff; x >>= 8; + p[3] = x & 0xff; x >>= 8; +} +#define WL32(p, x) write_u32le((uint8_t *)(p), (uint32_t)(x)) + +/** + * Write a 40 bits unsigned integer to memory stored as little endian. + * @param p a pointer to the output memory + * @param x the input unsigned integer + */ +static inline void write_u40le(uint8_t *p, uint64_t x) +{ + p[0] = x & 0xff; x >>= 8; + p[1] = x & 0xff; x >>= 8; + p[2] = x & 0xff; x >>= 8; + p[3] = x & 0xff; x >>= 8; + p[4] = x & 0xff; x >>= 8; +} +#define WL40(p, x) write_u40le((uint8_t *)(p), (uint64_t)(x)) + +/** + * Write a 48 bits unsigned integer to memory stored as little endian. + * @param p a pointer to the output memory + * @param x the input unsigned integer + */ +static inline void write_u48le(uint8_t *p, uint64_t x) +{ + p[0] = x & 0xff; x >>= 8; + p[1] = x & 0xff; x >>= 8; + p[2] = x & 0xff; x >>= 8; + p[3] = x & 0xff; x >>= 8; + p[4] = x & 0xff; x >>= 8; + p[5] = x & 0xff; x >>= 8; +} +#define WL48(p, x) write_u48le((uint8_t *)(p), (uint64_t)(x)) + +/** + * Write a 64 bits unsigned integer to memory stored as big endian. + * @param p a pointer to the output memory + * @param x the input unsigned integer + */ +static inline void write_u64be(uint8_t *p, uint64_t x) +{ + p[7] = x & 0xff; x >>= 8; + p[6] = x & 0xff; x >>= 8; + p[5] = x & 0xff; x >>= 8; + p[4] = x & 0xff; x >>= 8; + p[3] = x & 0xff; x >>= 8; + p[2] = x & 0xff; x >>= 8; + p[1] = x & 0xff; x >>= 8; + p[0] = x & 0xff; x >>= 8; +} + +/** + * Write a 64 bits unsigned integer to memory stored as little endian. + * @param p a pointer to the output memory + * @param x the input unsigned integer + */ +static inline void write_u64le(uint8_t *p, uint64_t x) +{ + p[0] = x & 0xff; x >>= 8; + p[1] = x & 0xff; x >>= 8; + p[2] = x & 0xff; x >>= 8; + p[3] = x & 0xff; x >>= 8; + p[4] = x & 0xff; x >>= 8; + p[5] = x & 0xff; x >>= 8; + p[6] = x & 0xff; x >>= 8; + p[7] = x & 0xff; x >>= 8; +} +#define WL64(p, x) write_u64le((uint8_t *)(p), (uint64_t)(x)) /** * Write a 32 bits float to memory stored as big endian. * @param p a pointer to the output memory * @param x the input float */ -#define WBFL(p, x) WB32(p, (union { uint32_t u; float f; }) { .f = x }.u) +static inline void write_fltbe(uint8_t *p, float x) +{ + union { uint32_t u; float f; } u; + u.f = x; + write_u32be(p, u.u); +} +#define WBFL(p, x) write_fltbe((uint8_t *)(p), (x)) /** * Write a 32 bits float to memory stored as little endian. * @param p a pointer to the output memory * @param x the input float */ -#define WLFL(p, x) WL32(p, (union { uint32_t u; float f; }) { .f = x }.u) +static inline void write_fltle(uint8_t *p, float x) +{ + union { uint32_t u; float f; } u; + u.f = x; + write_u32le(p, u.u); +} +#define WLFL(p, x) write_fltle((uint8_t *)(p), float (x)) + +/** + * Write a 64 bits float to memory stored as little endian. + * @param p a pointer to the output memory + * @param x the input floating point value + */ +static inline void write_dblle(uint8_t *p, double x) +{ + union { uint64_t u; double f; } u; + u.f = x; + write_u64le(p, u.u); +} +#define WLDB(p, x) write_dblle((uint8_t *)(p), float (x)) + +/* Endianess conversion helpers with read/write position increment. */ + +/** + * Read unsigned 8bit integer from raw memory, increment read position. + * @param[in, out] p Pointer into byte stream. + * @return Retrieved integer value, unsigned. + */ +static inline uint8_t read_u8_inc(const uint8_t **p) +{ + uint8_t v; + + if (!p || !*p) + return 0; + v = read_u8(*p); + *p += sizeof(v); + + return v; +} + +/** + * Read unsigned 8bit integer, check length, increment read position. + * @param[in, out] p Pointer into byte stream. + * @param[in, out] l Remaining input payload length. + * @return Retrieved integer value, unsigned. + */ +static inline uint8_t read_u8_inc_len(const uint8_t **p, size_t *l) +{ + uint8_t v; + + if (!p || !*p) + return 0; + if (l && *l < sizeof(v)) { + *l = 0; + return 0; + } + v = read_u8(*p); + *p += sizeof(v); + if (l) + *l -= sizeof(v); + + return v; +} + +/** + * Read signed 8bit integer from raw memory, increment read position. + * @param[in, out] p Pointer into byte stream. + * @return Retrieved integer value, signed. + */ +static inline int8_t read_i8_inc(const uint8_t **p) +{ + int8_t v; + + if (!p || !*p) + return 0; + v = read_i8(*p); + *p += sizeof(v); + + return v; +} + +/** + * Read unsigned 16bit integer from raw memory (big endian format), increment read position. + * @param[in, out] p Pointer into byte stream. + * @return Retrieved integer value, unsigned. + */ +static inline uint16_t read_u16be_inc(const uint8_t **p) +{ + uint16_t v; + + if (!p || !*p) + return 0; + v = read_u16be(*p); + *p += sizeof(v); + + return v; +} + +/** + * Read unsigned 16bit integer from raw memory (little endian format), increment read position. + * @param[in, out] p Pointer into byte stream. + * @return Retrieved integer value, unsigned. + */ +static inline uint16_t read_u16le_inc(const uint8_t **p) +{ + uint16_t v; + + if (!p || !*p) + return 0; + v = read_u16le(*p); + *p += sizeof(v); + + return v; +} + +/** + * Read unsigned 16bit integer (LE format), check length, increment position. + * @param[in, out] p Pointer into byte stream. + * @param[in, out] l Remaining input payload length. + * @return Retrieved integer value, unsigned. + */ +static inline uint16_t read_u16le_inc_len(const uint8_t **p, size_t *l) +{ + uint16_t v; + + if (!p || !*p) + return 0; + if (l && *l < sizeof(v)) { + *l = 0; + return 0; + } + v = read_u16le(*p); + *p += sizeof(v); + if (l) + *l -= sizeof(v); + + return v; +} + +/** + * Read signed 16bit integer from raw memory (big endian format), increment read position. + * @param[in, out] p Pointer into byte stream. + * @return Retrieved integer value, signed. + */ +static inline int16_t read_i16be_inc(const uint8_t **p) +{ + int16_t v; + + if (!p || !*p) + return 0; + v = read_i16be(*p); + *p += sizeof(v); + + return v; +} + +/** + * Read signed 16bit integer from raw memory (little endian format), increment read position. + * @param[in, out] p Pointer into byte stream. + * @return Retrieved integer value, signed. + */ +static inline int16_t read_i16le_inc(const uint8_t **p) +{ + int16_t v; + + if (!p || !*p) + return 0; + v = read_i16le(*p); + *p += sizeof(v); + + return v; +} + +/** + * Read unsigned 24bit integer from raw memory (little endian format), increment read position. + * @param[in, out] p Pointer into byte stream. + * @return Retrieved integer value, unsigned. + */ +static inline uint32_t read_u24le_inc(const uint8_t **p) +{ + uint32_t v; + + if (!p || !*p) + return 0; + v = read_u24le(*p); + *p += 3 * sizeof(uint8_t); + + return v; +} + +/** + * Read unsigned 32bit integer from raw memory (big endian format), increment read position. + * @param[in, out] p Pointer into byte stream. + * @return Retrieved integer value, unsigned. + */ +static inline uint32_t read_u32be_inc(const uint8_t **p) +{ + uint32_t v; + + if (!p || !*p) + return 0; + v = read_u32be(*p); + *p += sizeof(v); + + return v; +} + +/** + * Read unsigned 32bit integer from raw memory (little endian format), increment read position. + * @param[in, out] p Pointer into byte stream. + * @return Retrieved integer value, unsigned. + */ +static inline uint32_t read_u32le_inc(const uint8_t **p) +{ + uint32_t v; + + if (!p || !*p) + return 0; + v = read_u32le(*p); + *p += sizeof(v); + + return v; +} + +/** + * Read signed 32bit integer from raw memory (big endian format), increment read position. + * @param[in, out] p Pointer into byte stream. + * @return Retrieved integer value, signed. + */ +static inline int32_t read_i32be_inc(const uint8_t **p) +{ + int32_t v; + + if (!p || !*p) + return 0; + v = read_i32be(*p); + *p += sizeof(v); + + return v; +} + +/** + * Read signed 32bit integer from raw memory (little endian format), increment read position. + * @param[in, out] p Pointer into byte stream. + * @return Retrieved integer value, signed. + */ +static inline int32_t read_i32le_inc(const uint8_t **p) +{ + int32_t v; + + if (!p || !*p) + return 0; + v = read_i32le(*p); + *p += sizeof(v); + + return v; +} + +/** + * Read unsigned 64bit integer from raw memory (big endian format), increment read position. + * @param[in, out] p Pointer into byte stream. + * @return Retrieved integer value, unsigned. + */ +static inline uint64_t read_u64be_inc(const uint8_t **p) +{ + uint64_t v; + + if (!p || !*p) + return 0; + v = read_u64be(*p); + *p += sizeof(v); + + return v; +} + +/** + * Read unsigned 64bit integer from raw memory (little endian format), increment read position. + * @param[in, out] p Pointer into byte stream. + * @return Retrieved integer value, unsigned. + */ +static inline uint64_t read_u64le_inc(const uint8_t **p) +{ + uint64_t v; + + if (!p || !*p) + return 0; + v = read_u64le(*p); + *p += sizeof(v); + + return v; +} + +/** + * Read 32bit float from raw memory (big endian format), increment read position. + * @param[in, out] p Pointer into byte stream. + * @return Retrieved float value. + */ +static inline float read_fltbe_inc(const uint8_t **p) +{ + float v; + + if (!p || !*p) + return 0; + v = read_fltbe(*p); + *p += sizeof(v); + + return v; +} + +/** + * Read 32bit float from raw memory (little endian format), increment read position. + * @param[in, out] p Pointer into byte stream. + * @return Retrieved float value. + */ +static inline float read_fltle_inc(const uint8_t **p) +{ + float v; + + if (!p || !*p) + return 0; + v = read_fltle(*p); + *p += sizeof(v); + + return v; +} + +/** + * Read 64bit float from raw memory (big endian format), increment read position. + * @param[in, out] p Pointer into byte stream. + * @return Retrieved float value. + */ +static inline double read_dblbe_inc(const uint8_t **p) +{ + double v; + + if (!p || !*p) + return 0; + v = read_dblbe(*p); + *p += sizeof(v); + + return v; +} + +/** + * Read 64bit float from raw memory (little endian format), increment read position. + * @param[in, out] p Pointer into byte stream. + * @return Retrieved float value. + */ +static inline double read_dblle_inc(const uint8_t **p) +{ + double v; + + if (!p || !*p) + return 0; + v = read_dblle(*p); + *p += sizeof(v); + + return v; +} + +/** + * Write unsigned 8bit integer to raw memory, increment write position. + * @param[in, out] p Pointer into byte stream. + * @param[in] x Value to write. + */ +static inline void write_u8_inc(uint8_t **p, uint8_t x) +{ + if (!p || !*p) + return; + write_u8(*p, x); + *p += sizeof(x); +} + +/** + * Write unsigned 16bit big endian integer to raw memory, increment write position. + * @param[in, out] p Pointer into byte stream. + * @param[in] x Value to write. + */ +static inline void write_u16be_inc(uint8_t **p, uint16_t x) +{ + if (!p || !*p) + return; + write_u16be(*p, x); + *p += sizeof(x); +} + +/** + * Write unsigned 16bit little endian integer to raw memory, increment write position. + * @param[in, out] p Pointer into byte stream. + * @param[in] x Value to write. + */ +static inline void write_u16le_inc(uint8_t **p, uint16_t x) +{ + if (!p || !*p) + return; + write_u16le(*p, x); + *p += sizeof(x); +} + +/** + * Write unsigned 24bit liggle endian integer to raw memory, increment write position. + * @param[in, out] p Pointer into byte stream. + * @param[in] x Value to write. + */ +static inline void write_u24le_inc(uint8_t **p, uint32_t x) +{ + if (!p || !*p) + return; + write_u24le(*p, x); + *p += 3 * sizeof(uint8_t); +} + +/** + * Write unsigned 32bit big endian integer to raw memory, increment write position. + * @param[in, out] p Pointer into byte stream. + * @param[in] x Value to write. + */ +static inline void write_u32be_inc(uint8_t **p, uint32_t x) +{ + if (!p || !*p) + return; + write_u32be(*p, x); + *p += sizeof(x); +} + +/** + * Write unsigned 32bit little endian integer to raw memory, increment write position. + * @param[in, out] p Pointer into byte stream. + * @param[in] x Value to write. + */ +static inline void write_u32le_inc(uint8_t **p, uint32_t x) +{ + if (!p || !*p) + return; + write_u32le(*p, x); + *p += sizeof(x); +} + +/** + * Write unsigned 40bit little endian integer to raw memory, increment write position. + * @param[in, out] p Pointer into byte stream. + * @param[in] x Value to write. + */ +static inline void write_u40le_inc(uint8_t **p, uint64_t x) +{ + if (!p || !*p) + return; + write_u40le(*p, x); + *p += 5 * sizeof(uint8_t); +} + +/** + * Write unsigned 48bit little endian integer to raw memory, increment write position. + * @param[in, out] p Pointer into byte stream. + * @param[in] x Value to write. + */ +static inline void write_u48le_inc(uint8_t **p, uint64_t x) +{ + if (!p || !*p) + return; + write_u48le(*p, x); + *p += 48 / 8 * sizeof(uint8_t); +} + +/** + * Write unsigned 64bit little endian integer to raw memory, increment write position. + * @param[in, out] p Pointer into byte stream. + * @param[in] x Value to write. + */ +static inline void write_u64le_inc(uint8_t **p, uint64_t x) +{ + if (!p || !*p) + return; + write_u64le(*p, x); + *p += sizeof(x); +} + +/** + * Write single precision little endian float to raw memory, increment write position. + * @param[in, out] p Pointer into byte stream. + * @param[in] x Value to write. + */ +static inline void write_fltle_inc(uint8_t **p, float x) +{ + if (!p || !*p) + return; + write_fltle(*p, x); + *p += sizeof(x); +} + +/** + * Write double precision little endian float to raw memory, increment write position. + * @param[in, out] p Pointer into byte stream. + * @param[in] x Value to write. + */ +static inline void write_dblle_inc(uint8_t **p, double x) +{ + if (!p || !*p) + return; + write_dblle(*p, x); + *p += sizeof(x); +} /* Portability fixes for FreeBSD. */ #ifdef __FreeBSD__ @@ -260,6 +1103,21 @@ struct zip_stat; libusb_handle_events_timeout(ctx, tv) #endif +/* + * Convenience for FTDI library version dependency. + * - Version 1.5 introduced ftdi_tciflush(), ftdi_tcoflush(), and + * ftdi_tcioflush() all within the same commit, and deprecated + * ftdi_usb_purge_buffers() which suffered from inverse semantics. + * The API is drop-in compatible (arguments count and data types are + * identical). The libsigrok source code always flushes RX and TX at + * the same time, never individually. + */ +#if defined HAVE_FTDI_TCIOFLUSH && HAVE_FTDI_TCIOFLUSH +# define PURGE_FTDI_BOTH ftdi_tcioflush +#else +# define PURGE_FTDI_BOTH ftdi_usb_purge_buffers +#endif + /* Static definitions of structs ending with an all-zero entry are a * problem when compiling with -Wmissing-field-initializers: GCC * suppresses the warning only with { 0 }, clang wants { } */ @@ -272,7 +1130,16 @@ struct zip_stat; #ifdef __APPLE__ #define SR_DRIVER_LIST_SECTION "__DATA,__sr_driver_list" #else -#define SR_DRIVER_LIST_SECTION "sr_driver_list" +#define SR_DRIVER_LIST_SECTION "__sr_driver_list" +#endif + +#if !defined SR_DRIVER_LIST_NOREORDER && defined __has_attribute +#if __has_attribute(no_reorder) +#define SR_DRIVER_LIST_NOREORDER __attribute__((no_reorder)) +#endif +#endif +#if !defined SR_DRIVER_LIST_NOREORDER +#define SR_DRIVER_LIST_NOREORDER /* EMPTY */ #endif /** @@ -304,6 +1171,7 @@ struct zip_stat; */ #define SR_REGISTER_DEV_DRIVER_LIST(name, ...) \ static const struct sr_dev_driver *name[] \ + SR_DRIVER_LIST_NOREORDER \ __attribute__((section (SR_DRIVER_LIST_SECTION), used, \ aligned(sizeof(struct sr_dev_driver *)))) \ = { \ @@ -720,14 +1588,79 @@ struct sr_usb_dev_inst { }; #endif -#ifdef HAVE_LIBSERIALPORT +/** Raw TCP device instance. */ +struct sr_tcp_dev_inst { + char *host_addr; /**!< IP address or host name */ + char *tcp_port; /**!< TCP port number/name */ + int sock_fd; /**!< TCP socket's file descriptor */ +}; + +struct sr_serial_dev_inst; +#ifdef HAVE_SERIAL_COMM +struct ser_lib_functions; +struct ser_hid_chip_functions; +struct sr_bt_desc; +typedef void (*serial_rx_chunk_callback)(struct sr_serial_dev_inst *serial, + void *cb_data, const void *buf, size_t count); struct sr_serial_dev_inst { /** Port name, e.g. '/dev/tty42'. */ char *port; /** Comm params for serial_set_paramstr(). */ char *serialcomm; + struct ser_lib_functions *lib_funcs; + struct { + int bit_rate; + int data_bits; + int parity_bits; + int stop_bits; + } comm_params; + GString *rcv_buffer; + serial_rx_chunk_callback rx_chunk_cb_func; + void *rx_chunk_cb_data; +#ifdef HAVE_LIBSERIALPORT /** libserialport port handle */ - struct sp_port *data; + struct sp_port *sp_data; +#endif +#ifdef HAVE_LIBHIDAPI + enum ser_hid_chip_t { + SER_HID_CHIP_UNKNOWN, /**!< place holder */ + SER_HID_CHIP_BTC_BU86X, /**!< Brymen BU86x */ + SER_HID_CHIP_SIL_CP2110, /**!< SiLabs CP2110 */ + SER_HID_CHIP_VICTOR_DMM, /**!< Victor 70/86 DMM cable */ + SER_HID_CHIP_WCH_CH9325, /**!< WCH CH9325 */ + SER_HID_CHIP_LAST, /**!< sentinel */ + } hid_chip; + struct ser_hid_chip_functions *hid_chip_funcs; + char *usb_path; + char *usb_serno; + const char *hid_path; + hid_device *hid_dev; + GSList *hid_source_args; +#endif +#ifdef HAVE_BLUETOOTH + enum ser_bt_conn_t { + SER_BT_CONN_UNKNOWN, /**!< place holder */ + SER_BT_CONN_RFCOMM, /**!< BT classic, RFCOMM channel */ + SER_BT_CONN_BLE122, /**!< BLE, BLE122 module, indications */ + SER_BT_CONN_NRF51, /**!< BLE, Nordic nRF51, notifications */ + SER_BT_CONN_CC254x, /**!< BLE, TI CC254x, notifications */ + SER_BT_CONN_AC6328, /**!< BLE, JL AC6328B, notifications */ + SER_BT_CONN_DIALOG, /**!< BLE, dialog DA14580, notifications */ + SER_BT_CONN_NOTIFY, /**!< BLE, generic notifications */ + SER_BT_CONN_MAX, /**!< sentinel */ + } bt_conn_type; + char *bt_addr_local; + char *bt_addr_remote; + size_t bt_rfcomm_channel; + uint16_t bt_notify_handle_read; + uint16_t bt_notify_handle_write; + uint16_t bt_notify_handle_cccd; + uint16_t bt_notify_value_cccd; + uint16_t bt_ble_mtu; + struct sr_bt_desc *bt_desc; + GSList *bt_source_args; +#endif + struct sr_tcp_dev_inst *tcp_dev; }; #endif @@ -745,17 +1678,20 @@ struct drv_context { /*--- log.c -----------------------------------------------------------------*/ +/* Provide a macro for other source code locations to re-use. */ #if defined(_WIN32) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4)) /* * On MinGW, we need to specify the gnu_printf format flavor or GCC * will assume non-standard Microsoft printf syntax. */ -SR_PRIV int sr_log(int loglevel, const char *format, ...) - __attribute__((__format__ (__gnu_printf__, 2, 3))); +#define ATTR_FMT_PRINTF(fmt_pos, arg_pos) \ + __attribute__((__format__ (__gnu_printf__, fmt_pos, arg_pos))) #else -SR_PRIV int sr_log(int loglevel, const char *format, ...) G_GNUC_PRINTF(2, 3); +#define ATTR_FMT_PRINTF(fmt_pos, arg_pos) G_GNUC_PRINTF(fmt_pos, arg_pos) #endif +SR_PRIV int sr_log(int loglevel, const char *format, ...) ATTR_FMT_PRINTF(2, 3); + /* Message logging helpers with subsystem-specific prefix string. */ #define sr_spew(...) sr_log(SR_LOG_SPEW, LOG_PREFIX ": " __VA_ARGS__) #define sr_dbg(...) sr_log(SR_LOG_DBG, LOG_PREFIX ": " __VA_ARGS__) @@ -789,6 +1725,11 @@ SR_PRIV struct sr_channel *sr_next_enabled_channel(const struct sr_dev_inst *sdi SR_PRIV gboolean sr_channels_differ(struct sr_channel *ch1, struct sr_channel *ch2); SR_PRIV gboolean sr_channel_lists_differ(GSList *l1, GSList *l2); +SR_PRIV struct sr_channel_group *sr_channel_group_new(struct sr_dev_inst *sdi, + const char *name, void *priv); +SR_PRIV void sr_channel_group_free(struct sr_channel_group *cg); +SR_PRIV void sr_channel_group_free_cb(void *cg); + /** Device instance data */ struct sr_dev_inst { /** Device driver. */ @@ -827,9 +1768,34 @@ SR_PRIV void sr_dev_inst_free(struct sr_dev_inst *sdi); SR_PRIV struct sr_usb_dev_inst *sr_usb_dev_inst_new(uint8_t bus, uint8_t address, struct libusb_device_handle *hdl); SR_PRIV void sr_usb_dev_inst_free(struct sr_usb_dev_inst *usb); +SR_PRIV void sr_usb_dev_inst_free_cb(gpointer p); /* Glib wrapper. */ +#endif + +#ifdef HAVE_SERIAL_COMM +#ifndef HAVE_LIBSERIALPORT +/* + * Some identifiers which initially got provided by libserialport are + * used internally within the libsigrok serial layer's implementation, + * while libserialport no longer is the exclusive provider of serial + * communication support. Declare the identifiers here so they remain + * available across all build configurations. + */ +enum libsp_parity { + SP_PARITY_NONE = 0, + SP_PARITY_ODD = 1, + SP_PARITY_EVEN = 2, + SP_PARITY_MARK = 3, + SP_PARITY_SPACE = 4, +}; + +enum libsp_flowcontrol { + SP_FLOWCONTROL_NONE = 0, + SP_FLOWCONTROL_XONXOFF = 1, + SP_FLOWCONTROL_RTSCTS = 2, + SP_FLOWCONTROL_DTRDSR = 3, +}; #endif -#ifdef HAVE_LIBSERIALPORT /* Serial-specific instances */ SR_PRIV struct sr_serial_dev_inst *sr_serial_dev_inst_new(const char *port, const char *serialcomm); @@ -946,14 +1912,15 @@ SR_PRIV int std_dummy_dev_open(struct sr_dev_inst *sdi); SR_PRIV int std_dummy_dev_close(struct sr_dev_inst *sdi); SR_PRIV int std_dummy_dev_acquisition_start(const struct sr_dev_inst *sdi); SR_PRIV int std_dummy_dev_acquisition_stop(struct sr_dev_inst *sdi); -#ifdef HAVE_LIBSERIALPORT +#ifdef HAVE_SERIAL_COMM SR_PRIV int std_serial_dev_open(struct sr_dev_inst *sdi); SR_PRIV int std_serial_dev_acquisition_stop(struct sr_dev_inst *sdi); #endif SR_PRIV int std_session_send_df_header(const struct sr_dev_inst *sdi); SR_PRIV int std_session_send_df_end(const struct sr_dev_inst *sdi); -SR_PRIV int std_session_send_frame_begin(const struct sr_dev_inst *sdi); -SR_PRIV int std_session_send_frame_end(const struct sr_dev_inst *sdi); +SR_PRIV int std_session_send_df_trigger(const struct sr_dev_inst *sdi); +SR_PRIV int std_session_send_df_frame_begin(const struct sr_dev_inst *sdi); +SR_PRIV int std_session_send_df_frame_end(const struct sr_dev_inst *sdi); SR_PRIV int std_dev_clear_with_callback(const struct sr_dev_driver *driver, std_dev_clear_callback clear_private); SR_PRIV int std_dev_clear(const struct sr_dev_driver *driver); @@ -1003,6 +1970,12 @@ SR_PRIV int std_double_tuple_idx_d0(const double d, const double a[][2], unsigne SR_PRIV int std_cg_idx(const struct sr_channel_group *cg, struct sr_channel_group *a[], unsigned int n); +SR_PRIV int std_dummy_set_params(struct sr_serial_dev_inst *serial, + int baudrate, int bits, int parity, int stopbits, + int flowcontrol, int rts, int dtr); +SR_PRIV int std_dummy_set_handshake(struct sr_serial_dev_inst *serial, + int rts, int dtr); + /*--- resource.c ------------------------------------------------------------*/ SR_PRIV int64_t sr_file_get_size(FILE *file); @@ -1022,10 +1995,13 @@ SR_PRIV void *sr_resource_load(struct sr_context *ctx, int type, /*--- strutil.c -------------------------------------------------------------*/ SR_PRIV int sr_atol(const char *str, long *ret); +SR_PRIV int sr_atol_base(const char *str, long *ret, char **end, int base); +SR_PRIV int sr_atoul_base(const char *str, unsigned long *ret, char **end, int base); SR_PRIV int sr_atoi(const char *str, int *ret); SR_PRIV int sr_atod(const char *str, double *ret); SR_PRIV int sr_atof(const char *str, float *ret); SR_PRIV int sr_atod_ascii(const char *str, double *ret); +SR_PRIV int sr_atod_ascii_digits(const char *str, double *ret, int *digits); SR_PRIV int sr_atof_ascii(const char *str, float *ret); SR_PRIV GString *sr_hexdump_new(const uint8_t *data, const size_t len); @@ -1054,20 +2030,27 @@ SR_PRIV void soft_trigger_logic_free(struct soft_trigger_logic *st); SR_PRIV int soft_trigger_logic_check(struct soft_trigger_logic *st, uint8_t *buf, int len, int *pre_trigger_samples); -/*--- hardware/serial.c -----------------------------------------------------*/ +/*--- serial.c --------------------------------------------------------------*/ -#ifdef HAVE_LIBSERIALPORT +#ifdef HAVE_SERIAL_COMM enum { SERIAL_RDWR = 1, SERIAL_RDONLY = 2, }; typedef gboolean (*packet_valid_callback)(const uint8_t *buf); +typedef int (*packet_valid_len_callback)(void *st, + const uint8_t *p, size_t l, size_t *pl); + +typedef GSList *(*sr_ser_list_append_t)(GSList *devs, const char *name, + const char *desc); +typedef GSList *(*sr_ser_find_append_t)(GSList *devs, const char *name); SR_PRIV int serial_open(struct sr_serial_dev_inst *serial, int flags); SR_PRIV int serial_close(struct sr_serial_dev_inst *serial); SR_PRIV int serial_flush(struct sr_serial_dev_inst *serial); SR_PRIV int serial_drain(struct sr_serial_dev_inst *serial); +SR_PRIV size_t serial_has_receive_data(struct sr_serial_dev_inst *serial); SR_PRIV int serial_write_blocking(struct sr_serial_dev_inst *serial, const void *buf, size_t count, unsigned int timeout_ms); SR_PRIV int serial_write_nonblocking(struct sr_serial_dev_inst *serial, @@ -1076,19 +2059,21 @@ SR_PRIV int serial_read_blocking(struct sr_serial_dev_inst *serial, void *buf, size_t count, unsigned int timeout_ms); SR_PRIV int serial_read_nonblocking(struct sr_serial_dev_inst *serial, void *buf, size_t count); +SR_PRIV int serial_set_read_chunk_cb(struct sr_serial_dev_inst *serial, + serial_rx_chunk_callback cb, void *cb_data); SR_PRIV int serial_set_params(struct sr_serial_dev_inst *serial, int baudrate, int bits, int parity, int stopbits, int flowcontrol, int rts, int dtr); +SR_PRIV int serial_set_handshake(struct sr_serial_dev_inst *serial, + int rts, int dtr); SR_PRIV int serial_set_paramstr(struct sr_serial_dev_inst *serial, const char *paramstr); SR_PRIV int serial_readline(struct sr_serial_dev_inst *serial, char **buf, int *buflen, gint64 timeout_ms); SR_PRIV int serial_stream_detect(struct sr_serial_dev_inst *serial, - uint8_t *buf, size_t *buflen, - size_t packet_size, - packet_valid_callback is_valid, - uint64_t timeout_ms, int baudrate); -SR_PRIV int sr_serial_extract_options(GSList *options, const char **serial_device, - const char **serial_options); + uint8_t *buf, size_t *buflen, + size_t packet_size, packet_valid_callback is_valid, + packet_valid_len_callback is_valid_len, size_t *return_size, + uint64_t timeout_ms); SR_PRIV int serial_source_add(struct sr_session *session, struct sr_serial_dev_inst *serial, int events, int timeout, sr_receive_data_callback cb, void *cb_data); @@ -1096,9 +2081,123 @@ SR_PRIV int serial_source_remove(struct sr_session *session, struct sr_serial_dev_inst *serial); SR_PRIV GSList *sr_serial_find_usb(uint16_t vendor_id, uint16_t product_id); SR_PRIV int serial_timeout(struct sr_serial_dev_inst *port, int num_bytes); + +SR_PRIV void sr_ser_discard_queued_data(struct sr_serial_dev_inst *serial); +SR_PRIV size_t sr_ser_has_queued_data(struct sr_serial_dev_inst *serial); +SR_PRIV void sr_ser_queue_rx_data(struct sr_serial_dev_inst *serial, + const uint8_t *data, size_t len); +SR_PRIV size_t sr_ser_unqueue_rx_data(struct sr_serial_dev_inst *serial, + uint8_t *data, size_t len); + +struct ser_lib_functions { + int (*open)(struct sr_serial_dev_inst *serial, int flags); + int (*close)(struct sr_serial_dev_inst *serial); + int (*flush)(struct sr_serial_dev_inst *serial); + int (*drain)(struct sr_serial_dev_inst *serial); + int (*write)(struct sr_serial_dev_inst *serial, + const void *buf, size_t count, + int nonblocking, unsigned int timeout_ms); + int (*read)(struct sr_serial_dev_inst *serial, + void *buf, size_t count, + int nonblocking, unsigned int timeout_ms); + int (*set_params)(struct sr_serial_dev_inst *serial, + int baudrate, int bits, int parity, int stopbits, + int flowcontrol, int rts, int dtr); + int (*set_handshake)(struct sr_serial_dev_inst *serial, + int rts, int dtr); + int (*setup_source_add)(struct sr_session *session, + struct sr_serial_dev_inst *serial, + int events, int timeout, + sr_receive_data_callback cb, void *cb_data); + int (*setup_source_remove)(struct sr_session *session, + struct sr_serial_dev_inst *serial); + GSList *(*list)(GSList *list, sr_ser_list_append_t append); + GSList *(*find_usb)(GSList *list, sr_ser_find_append_t append, + uint16_t vendor_id, uint16_t product_id); + int (*get_frame_format)(struct sr_serial_dev_inst *serial, + int *baud, int *bits); + size_t (*get_rx_avail)(struct sr_serial_dev_inst *serial); +}; +extern SR_PRIV struct ser_lib_functions *ser_lib_funcs_libsp; +SR_PRIV int ser_name_is_hid(struct sr_serial_dev_inst *serial); +extern SR_PRIV struct ser_lib_functions *ser_lib_funcs_hid; +SR_PRIV int ser_name_is_bt(struct sr_serial_dev_inst *serial); +extern SR_PRIV struct ser_lib_functions *ser_lib_funcs_bt; +SR_PRIV int ser_name_is_tcpraw(struct sr_serial_dev_inst *serial); +extern SR_PRIV struct ser_lib_functions *ser_lib_funcs_tcpraw; + +#ifdef HAVE_LIBHIDAPI +struct vid_pid_item { + uint16_t vid, pid; +}; + +struct ser_hid_chip_functions { + const char *chipname; + const char *chipdesc; + const struct vid_pid_item *vid_pid_items; + const int max_bytes_per_request; + int (*set_params)(struct sr_serial_dev_inst *serial, + int baudrate, int bits, int parity, int stopbits, + int flowcontrol, int rts, int dtr); + int (*read_bytes)(struct sr_serial_dev_inst *serial, + uint8_t *data, int space, unsigned int timeout); + int (*write_bytes)(struct sr_serial_dev_inst *serial, + const uint8_t *data, int space); + int (*flush)(struct sr_serial_dev_inst *serial); + int (*drain)(struct sr_serial_dev_inst *serial); +}; +extern SR_PRIV struct ser_hid_chip_functions *ser_hid_chip_funcs_bu86x; +extern SR_PRIV struct ser_hid_chip_functions *ser_hid_chip_funcs_ch9325; +extern SR_PRIV struct ser_hid_chip_functions *ser_hid_chip_funcs_cp2110; +extern SR_PRIV struct ser_hid_chip_functions *ser_hid_chip_funcs_victor; +SR_PRIV const char *ser_hid_chip_find_name_vid_pid(uint16_t vid, uint16_t pid); +#endif +#endif + +SR_PRIV int sr_serial_extract_options(GSList *options, + const char **serial_device, const char **serial_options); + +/*--- bt/ API ---------------------------------------------------------------*/ + +#ifdef HAVE_BLUETOOTH +SR_PRIV const char *sr_bt_adapter_get_address(size_t idx); + +struct sr_bt_desc; +typedef void (*sr_bt_scan_cb)(void *cb_data, const char *addr, const char *name); +typedef int (*sr_bt_data_cb)(void *cb_data, uint8_t *data, size_t dlen); + +SR_PRIV struct sr_bt_desc *sr_bt_desc_new(void); +SR_PRIV void sr_bt_desc_free(struct sr_bt_desc *desc); + +SR_PRIV int sr_bt_config_cb_scan(struct sr_bt_desc *desc, + sr_bt_scan_cb cb, void *cb_data); +SR_PRIV int sr_bt_config_cb_data(struct sr_bt_desc *desc, + sr_bt_data_cb cb, void *cb_data); +SR_PRIV int sr_bt_config_addr_local(struct sr_bt_desc *desc, const char *addr); +SR_PRIV int sr_bt_config_addr_remote(struct sr_bt_desc *desc, const char *addr); +SR_PRIV int sr_bt_config_rfcomm(struct sr_bt_desc *desc, size_t channel); +SR_PRIV int sr_bt_config_notify(struct sr_bt_desc *desc, + uint16_t read_handle, uint16_t write_handle, + uint16_t cccd_handle, uint16_t cccd_value, + uint16_t ble_mtu); + +SR_PRIV int sr_bt_scan_le(struct sr_bt_desc *desc, int duration); +SR_PRIV int sr_bt_scan_bt(struct sr_bt_desc *desc, int duration); + +SR_PRIV int sr_bt_connect_ble(struct sr_bt_desc *desc); +SR_PRIV int sr_bt_connect_rfcomm(struct sr_bt_desc *desc); +SR_PRIV void sr_bt_disconnect(struct sr_bt_desc *desc); + +SR_PRIV ssize_t sr_bt_read(struct sr_bt_desc *desc, + void *data, size_t len); +SR_PRIV ssize_t sr_bt_write(struct sr_bt_desc *desc, + const void *data, size_t len); + +SR_PRIV int sr_bt_start_notify(struct sr_bt_desc *desc); +SR_PRIV int sr_bt_check_notify(struct sr_bt_desc *desc); #endif -/*--- hardware/ezusb.c ------------------------------------------------------*/ +/*--- ezusb.c ---------------------------------------------------------------*/ #ifdef HAVE_LIBUSB_1_0 SR_PRIV int ezusb_reset(struct libusb_device_handle *hdl, int set_clear); @@ -1108,8 +2207,10 @@ SR_PRIV int ezusb_upload_firmware(struct sr_context *ctx, libusb_device *dev, int configuration, const char *name); #endif -/*--- hardware/usb.c --------------------------------------------------------*/ +/*--- usb.c -----------------------------------------------------------------*/ +SR_PRIV int sr_usb_split_conn(const char *conn, + uint16_t *vid, uint16_t *pid, uint8_t *bus, uint8_t *addr); #ifdef HAVE_LIBUSB_1_0 SR_PRIV GSList *sr_usb_find(libusb_context *usb_ctx, const char *conn); SR_PRIV int sr_usb_open(libusb_context *usb_ctx, struct sr_usb_dev_inst *usb); @@ -1122,6 +2223,91 @@ SR_PRIV gboolean usb_match_manuf_prod(libusb_device *dev, const char *manufacturer, const char *product); #endif +/*--- tcp.c -----------------------------------------------------------------*/ + +SR_PRIV gboolean sr_fd_is_readable(int fd); + +SR_PRIV struct sr_tcp_dev_inst *sr_tcp_dev_inst_new( + const char *host_addr, const char *tcp_port); +SR_PRIV void sr_tcp_dev_inst_free(struct sr_tcp_dev_inst *tcp); +SR_PRIV int sr_tcp_get_port_path(struct sr_tcp_dev_inst *tcp, + const char *prefix, char separator, char *path, size_t path_len); +SR_PRIV int sr_tcp_connect(struct sr_tcp_dev_inst *tcp); +SR_PRIV int sr_tcp_disconnect(struct sr_tcp_dev_inst *tcp); +SR_PRIV int sr_tcp_write_bytes(struct sr_tcp_dev_inst *tcp, + const uint8_t *data, size_t dlen); +SR_PRIV int sr_tcp_read_bytes(struct sr_tcp_dev_inst *tcp, + uint8_t *data, size_t dlen, gboolean nonblocking); +SR_PRIV int sr_tcp_source_add(struct sr_session *session, + struct sr_tcp_dev_inst *tcp, int events, int timeout, + sr_receive_data_callback cb, void *cb_data); +SR_PRIV int sr_tcp_source_remove(struct sr_session *session, + struct sr_tcp_dev_inst *tcp); + +/*--- binary_helpers.c ------------------------------------------------------*/ + +/** Binary value type */ +enum binary_value_type { + BVT_INVALID, + + BVT_UINT8, + + BVT_BE_UINT16, + BVT_BE_UINT24, + BVT_BE_UINT32, + + BVT_LE_UINT16, + BVT_LE_UINT24, + BVT_LE_UINT32, +}; + +/** Binary value specification */ +struct binary_value_spec { + size_t offset; /**!< Offset into binary image */ + enum binary_value_type type; /**!< Data type to decode */ +}; + +/** + * Read extract a value from a binary data image, ensuring no out-of-bounds + * read happens. + * + * @param[out] out Pointer to output buffer (conversion result) + * @param[in] spec Binary value specification + * @param[in] data Pointer to binary input data + * @param[in] length Size of binary input data + * + * @return SR_OK on success, SR_ERR_* error code on failure. + */ +SR_PRIV int bv_get_value_len(float *out, const struct binary_value_spec *spec, + const uint8_t *data, size_t length); + +/** + * Read extract a value from a binary data image, without bound check. + * + * @param[out] out Pointer to output buffer (conversion result) + * @param[in] spec Binary value specification + * @param[in] data Pointer to binary input data + * + * @return SR_OK on success, SR_ERR_* error code on failure. + */ +SR_PRIV int bv_get_value(float *out, const struct binary_value_spec *spec, + const uint8_t *data); + +/*--- crc.c -----------------------------------------------------------------*/ + +#define SR_CRC16_DEFAULT_INIT 0xffffU + +/** + * Calculate a CRC16 checksum using the 0x8005 polynomial. + * + * This CRC16 flavor is also known as CRC16-ANSI or CRC16-MODBUS. + * + * @param crc Initial value (typically 0xffff) + * @param buffer Input buffer + * @param len Buffer length + * @return Checksum + */ +SR_PRIV uint16_t sr_crc16(uint16_t crc, const uint8_t *buffer, int len); /*--- modbus/modbus.c -------------------------------------------------------*/ @@ -1176,7 +2362,7 @@ SR_PRIV int sr_modbus_write_multiple_registers(struct sr_modbus_dev_inst*modbus, SR_PRIV int sr_modbus_close(struct sr_modbus_dev_inst *modbus); SR_PRIV void sr_modbus_free(struct sr_modbus_dev_inst *modbus); -/*--- hardware/dmm/es519xx.c ------------------------------------------------*/ +/*--- dmm/es519xx.c ---------------------------------------------------------*/ /** * All 11-byte es519xx chips repeat each block twice for each conversion cycle @@ -1222,7 +2408,7 @@ SR_PRIV gboolean sr_es519xx_19200_14b_sel_lpf_packet_valid(const uint8_t *buf); SR_PRIV int sr_es519xx_19200_14b_sel_lpf_parse(const uint8_t *buf, float *floatval, struct sr_datafeed_analog *analog, void *info); -/*--- hardware/dmm/fs9922.c -------------------------------------------------*/ +/*--- dmm/fs9922.c ----------------------------------------------------------*/ #define FS9922_PACKET_SIZE 14 @@ -1240,7 +2426,7 @@ SR_PRIV int sr_fs9922_parse(const uint8_t *buf, float *floatval, struct sr_datafeed_analog *analog, void *info); SR_PRIV void sr_fs9922_z1_diode(struct sr_datafeed_analog *analog, void *info); -/*--- hardware/dmm/fs9721.c -------------------------------------------------*/ +/*--- dmm/fs9721.c ----------------------------------------------------------*/ #define FS9721_PACKET_SIZE 14 @@ -1260,7 +2446,41 @@ SR_PRIV void sr_fs9721_10_temp_c(struct sr_datafeed_analog *analog, void *info); SR_PRIV void sr_fs9721_01_10_temp_f_c(struct sr_datafeed_analog *analog, void *info); SR_PRIV void sr_fs9721_max_c_min(struct sr_datafeed_analog *analog, void *info); -/*--- hardware/dmm/ms8250d.c ------------------------------------------------*/ +/*--- dmm/mm38xr.c ---------------------------------------------------------*/ + +#define METERMAN_38XR_PACKET_SIZE 15 + +struct meterman_38xr_info { int dummy; }; + +SR_PRIV gboolean meterman_38xr_packet_valid(const uint8_t *buf); +SR_PRIV int meterman_38xr_parse(const uint8_t *buf, float *floatval, + struct sr_datafeed_analog *analog, void *info); + +/*--- dmm/ms2115b.c ---------------------------------------------------------*/ + +#define MS2115B_PACKET_SIZE 9 + +enum ms2115b_display { + MS2115B_DISPLAY_MAIN, + MS2115B_DISPLAY_SUB, + MS2115B_DISPLAY_COUNT, +}; + +struct ms2115b_info { + /* Selected channel. */ + size_t ch_idx; + gboolean is_ac, is_dc, is_auto; + gboolean is_diode, is_beep, is_farad; + gboolean is_ohm, is_ampere, is_volt, is_hz; + gboolean is_duty_cycle, is_percent; +}; + +extern SR_PRIV const char *ms2115b_channel_formats[]; +SR_PRIV gboolean sr_ms2115b_packet_valid(const uint8_t *buf); +SR_PRIV int sr_ms2115b_parse(const uint8_t *buf, float *floatval, + struct sr_datafeed_analog *analog, void *info); + +/*--- dmm/ms8250d.c ---------------------------------------------------------*/ #define MS8250D_PACKET_SIZE 18 @@ -1275,7 +2495,7 @@ SR_PRIV gboolean sr_ms8250d_packet_valid(const uint8_t *buf); SR_PRIV int sr_ms8250d_parse(const uint8_t *buf, float *floatval, struct sr_datafeed_analog *analog, void *info); -/*--- hardware/dmm/dtm0660.c ------------------------------------------------*/ +/*--- dmm/dtm0660.c ---------------------------------------------------------*/ #define DTM0660_PACKET_SIZE 15 @@ -1291,7 +2511,7 @@ SR_PRIV gboolean sr_dtm0660_packet_valid(const uint8_t *buf); SR_PRIV int sr_dtm0660_parse(const uint8_t *buf, float *floatval, struct sr_datafeed_analog *analog, void *info); -/*--- hardware/dmm/m2110.c --------------------------------------------------*/ +/*--- dmm/m2110.c -----------------------------------------------------------*/ #define BBCGM_M2110_PACKET_SIZE 9 @@ -1302,7 +2522,7 @@ SR_PRIV gboolean sr_m2110_packet_valid(const uint8_t *buf); SR_PRIV int sr_m2110_parse(const uint8_t *buf, float *floatval, struct sr_datafeed_analog *analog, void *info); -/*--- hardware/dmm/metex14.c ------------------------------------------------*/ +/*--- dmm/metex14.c ---------------------------------------------------------*/ #define METEX14_PACKET_SIZE 14 @@ -1316,7 +2536,7 @@ struct metex14_info { gboolean is_hfe, is_unitless, is_logic, is_min, is_max, is_avg; }; -#ifdef HAVE_LIBSERIALPORT +#ifdef HAVE_SERIAL_COMM SR_PRIV int sr_metex14_packet_request(struct sr_serial_dev_inst *serial); #endif SR_PRIV gboolean sr_metex14_packet_valid(const uint8_t *buf); @@ -1326,7 +2546,7 @@ SR_PRIV gboolean sr_metex14_4packets_valid(const uint8_t *buf); SR_PRIV int sr_metex14_4packets_parse(const uint8_t *buf, float *floatval, struct sr_datafeed_analog *analog, void *info); -/*--- hardware/dmm/rs9lcd.c -------------------------------------------------*/ +/*--- dmm/rs9lcd.c ----------------------------------------------------------*/ #define RS9LCD_PACKET_SIZE 9 @@ -1337,7 +2557,7 @@ SR_PRIV gboolean sr_rs9lcd_packet_valid(const uint8_t *buf); SR_PRIV int sr_rs9lcd_parse(const uint8_t *buf, float *floatval, struct sr_datafeed_analog *analog, void *info); -/*--- hardware/dmm/bm25x.c --------------------------------------------------*/ +/*--- dmm/bm25x.c -----------------------------------------------------------*/ #define BRYMEN_BM25X_PACKET_SIZE 15 @@ -1348,7 +2568,67 @@ SR_PRIV gboolean sr_brymen_bm25x_packet_valid(const uint8_t *buf); SR_PRIV int sr_brymen_bm25x_parse(const uint8_t *buf, float *floatval, struct sr_datafeed_analog *analog, void *info); -/*--- hardware/dmm/ut71x.c --------------------------------------------------*/ +/*--- dmm/bm52x.c -----------------------------------------------------------*/ + +#define BRYMEN_BM52X_PACKET_SIZE 24 +#define BRYMEN_BM52X_DISPLAY_COUNT 2 + +struct brymen_bm52x_info { size_t ch_idx; }; + +#ifdef HAVE_SERIAL_COMM +SR_PRIV int sr_brymen_bm52x_packet_request(struct sr_serial_dev_inst *serial); +SR_PRIV int sr_brymen_bm82x_packet_request(struct sr_serial_dev_inst *serial); +#endif +SR_PRIV gboolean sr_brymen_bm52x_packet_valid(const uint8_t *buf); +SR_PRIV gboolean sr_brymen_bm82x_packet_valid(const uint8_t *buf); +/* BM520s and BM820s protocols are similar, the parse routine is shared. */ +SR_PRIV int sr_brymen_bm52x_parse(const uint8_t *buf, float *floatval, + struct sr_datafeed_analog *analog, void *info); + +struct brymen_bm52x_state; + +SR_PRIV void *brymen_bm52x_state_init(void); +SR_PRIV void brymen_bm52x_state_free(void *state); +SR_PRIV int brymen_bm52x_config_get(void *state, uint32_t key, GVariant **data, + const struct sr_dev_inst *sdi, const struct sr_channel_group *cg); +SR_PRIV int brymen_bm52x_config_set(void *state, uint32_t key, GVariant *data, + const struct sr_dev_inst *sdi, const struct sr_channel_group *cg); +SR_PRIV int brymen_bm52x_config_list(void *state, uint32_t key, GVariant **data, + const struct sr_dev_inst *sdi, const struct sr_channel_group *cg); +SR_PRIV int brymen_bm52x_acquire_start(void *state, + const struct sr_dev_inst *sdi, + sr_receive_data_callback *cb, void **cb_data); + +/*--- dmm/bm85x.c -----------------------------------------------------------*/ + +#define BRYMEN_BM85x_PACKET_SIZE_MIN 4 + +struct brymen_bm85x_info { int dummy; }; + +#ifdef HAVE_SERIAL_COMM +SR_PRIV int brymen_bm85x_after_open(struct sr_serial_dev_inst *serial); +SR_PRIV int brymen_bm85x_packet_request(struct sr_serial_dev_inst *serial); +#endif +SR_PRIV gboolean brymen_bm85x_packet_valid(void *state, + const uint8_t *buf, size_t len, size_t *pkt_len); +SR_PRIV int brymen_bm85x_parse(void *state, const uint8_t *buf, size_t len, + double *floatval, struct sr_datafeed_analog *analog, void *info); + +/*--- dmm/bm86x.c -----------------------------------------------------------*/ + +#define BRYMEN_BM86X_PACKET_SIZE 24 +#define BRYMEN_BM86X_DISPLAY_COUNT 2 + +struct brymen_bm86x_info { size_t ch_idx; }; + +#ifdef HAVE_SERIAL_COMM +SR_PRIV int sr_brymen_bm86x_packet_request(struct sr_serial_dev_inst *serial); +#endif +SR_PRIV gboolean sr_brymen_bm86x_packet_valid(const uint8_t *buf); +SR_PRIV int sr_brymen_bm86x_parse(const uint8_t *buf, float *floatval, + struct sr_datafeed_analog *analog, void *info); + +/*--- dmm/ut71x.c -----------------------------------------------------------*/ #define UT71X_PACKET_SIZE 11 @@ -1363,7 +2643,7 @@ SR_PRIV gboolean sr_ut71x_packet_valid(const uint8_t *buf); SR_PRIV int sr_ut71x_parse(const uint8_t *buf, float *floatval, struct sr_datafeed_analog *analog, void *info); -/*--- hardware/dmm/vc870.c --------------------------------------------------*/ +/*--- dmm/vc870.c -----------------------------------------------------------*/ #define VC870_PACKET_SIZE 23 @@ -1384,7 +2664,7 @@ SR_PRIV gboolean sr_vc870_packet_valid(const uint8_t *buf); SR_PRIV int sr_vc870_parse(const uint8_t *buf, float *floatval, struct sr_datafeed_analog *analog, void *info); -/*--- hardware/dmm/vc96.c ---------------------------------------------------*/ +/*--- dmm/vc96.c ------------------------------------------------------------*/ #define VC96_PACKET_SIZE 13 @@ -1399,25 +2679,57 @@ SR_PRIV gboolean sr_vc96_packet_valid(const uint8_t *buf); SR_PRIV int sr_vc96_parse(const uint8_t *buf, float *floatval, struct sr_datafeed_analog *analog, void *info); -/*--- hardware/lcr/es51919.c ------------------------------------------------*/ - -SR_PRIV void es51919_serial_clean(void *priv); -SR_PRIV struct sr_dev_inst *es51919_serial_scan(GSList *options, - const char *vendor, - const char *model); -SR_PRIV int es51919_serial_config_get(uint32_t key, GVariant **data, - const struct sr_dev_inst *sdi, - const struct sr_channel_group *cg); -SR_PRIV int es51919_serial_config_set(uint32_t key, GVariant *data, - const struct sr_dev_inst *sdi, - const struct sr_channel_group *cg); -SR_PRIV int es51919_serial_config_list(uint32_t key, GVariant **data, - const struct sr_dev_inst *sdi, - const struct sr_channel_group *cg); -SR_PRIV int es51919_serial_acquisition_start(const struct sr_dev_inst *sdi); -SR_PRIV int es51919_serial_acquisition_stop(struct sr_dev_inst *sdi); - -/*--- hardware/dmm/ut372.c --------------------------------------------------*/ +/*--- lcr/es51919.c ---------------------------------------------------------*/ + +/* Acquisition details which apply to all supported serial-lcr devices. */ +struct lcr_parse_info { + size_t ch_idx; + uint64_t output_freq; + const char *circuit_model; +}; + +#define ES51919_PACKET_SIZE 17 +#define ES51919_CHANNEL_COUNT 2 +#define ES51919_COMM_PARAM "9600/8n1/rts=1/dtr=1" + +SR_PRIV int es51919_config_get(uint32_t key, GVariant **data, + const struct sr_dev_inst *sdi, const struct sr_channel_group *cg); +SR_PRIV int es51919_config_set(uint32_t key, GVariant *data, + const struct sr_dev_inst *sdi, const struct sr_channel_group *cg); +SR_PRIV int es51919_config_list(uint32_t key, GVariant **data, + const struct sr_dev_inst *sdi, const struct sr_channel_group *cg); +SR_PRIV gboolean es51919_packet_valid(const uint8_t *pkt); +SR_PRIV int es51919_packet_parse(const uint8_t *pkt, float *floatval, + struct sr_datafeed_analog *analog, void *info); + +/*--- lcr/vc4080.c ----------------------------------------------------------*/ + +/* Note: Also uses 'struct lcr_parse_info' from es51919 above. */ + +#define VC4080_PACKET_SIZE 39 +#define VC4080_COMM_PARAM "1200/8n1" +#define VC4080_WITH_DQ_CHANS 0 /* Enable separate D/Q channels? */ + +enum vc4080_display { + VC4080_DISPLAY_PRIMARY, + VC4080_DISPLAY_SECONDARY, +#if VC4080_WITH_DQ_CHANS + VC4080_DISPLAY_D_VALUE, + VC4080_DISPLAY_Q_VALUE, +#endif + VC4080_CHANNEL_COUNT, +}; + +extern SR_PRIV const char *vc4080_channel_formats[VC4080_CHANNEL_COUNT]; + +SR_PRIV int vc4080_config_list(uint32_t key, GVariant **data, + const struct sr_dev_inst *sdi, const struct sr_channel_group *cg); +SR_PRIV int vc4080_packet_request(struct sr_serial_dev_inst *serial); +SR_PRIV gboolean vc4080_packet_valid(const uint8_t *pkt); +SR_PRIV int vc4080_packet_parse(const uint8_t *pkt, float *floatval, + struct sr_datafeed_analog *analog, void *info); + +/*--- dmm/ut372.c -----------------------------------------------------------*/ #define UT372_PACKET_SIZE 27 @@ -1429,7 +2741,7 @@ SR_PRIV gboolean sr_ut372_packet_valid(const uint8_t *buf); SR_PRIV int sr_ut372_parse(const uint8_t *buf, float *floatval, struct sr_datafeed_analog *analog, void *info); -/*--- hardware/dmm/asycii.c -------------------------------------------------*/ +/*--- dmm/asycii.c ----------------------------------------------------------*/ #define ASYCII_PACKET_SIZE 16 @@ -1447,14 +2759,14 @@ struct asycii_info { gboolean is_invalid; }; -#ifdef HAVE_LIBSERIALPORT +#ifdef HAVE_SERIAL_COMM SR_PRIV int sr_asycii_packet_request(struct sr_serial_dev_inst *serial); #endif SR_PRIV gboolean sr_asycii_packet_valid(const uint8_t *buf); SR_PRIV int sr_asycii_parse(const uint8_t *buf, float *floatval, struct sr_datafeed_analog *analog, void *info); -/*--- src/dmm/eev121gw.c ----------------------------------------------------*/ +/*--- dmm/eev121gw.c --------------------------------------------------------*/ #define EEV121GW_PACKET_SIZE 19 @@ -1492,12 +2804,10 @@ struct eev121gw_info { extern SR_PRIV const char *eev121gw_channel_formats[]; SR_PRIV gboolean sr_eev121gw_packet_valid(const uint8_t *buf); -SR_PRIV int sr_eev121gw_parse(const uint8_t *buf, float *floatval, - struct sr_datafeed_analog *analog, void *info); SR_PRIV int sr_eev121gw_3displays_parse(const uint8_t *buf, float *floatval, - struct sr_datafeed_analog *analog, void *info); + struct sr_datafeed_analog *analog, void *info); -/*--- hardware/scale/kern.c -------------------------------------------------*/ +/*--- scale/kern.c ----------------------------------------------------------*/ struct kern_info { gboolean is_gram, is_carat, is_ounce, is_pound, is_troy_ounce; @@ -1514,19 +2824,54 @@ SR_PRIV int sr_kern_parse(const uint8_t *buf, float *floatval, struct sr_sw_limits { uint64_t limit_samples; + uint64_t limit_frames; uint64_t limit_msec; uint64_t samples_read; + uint64_t frames_read; uint64_t start_time; }; -SR_PRIV int sr_sw_limits_config_get(struct sr_sw_limits *limits, uint32_t key, +SR_PRIV int sr_sw_limits_config_get(const struct sr_sw_limits *limits, uint32_t key, GVariant **data); SR_PRIV int sr_sw_limits_config_set(struct sr_sw_limits *limits, uint32_t key, GVariant *data); SR_PRIV void sr_sw_limits_acquisition_start(struct sr_sw_limits *limits); SR_PRIV gboolean sr_sw_limits_check(struct sr_sw_limits *limits); +SR_PRIV int sr_sw_limits_get_remain(const struct sr_sw_limits *limits, + uint64_t *samples, uint64_t *frames, uint64_t *msecs, + gboolean *exceeded); SR_PRIV void sr_sw_limits_update_samples_read(struct sr_sw_limits *limits, uint64_t samples_read); +SR_PRIV void sr_sw_limits_update_frames_read(struct sr_sw_limits *limits, + uint64_t frames_read); SR_PRIV void sr_sw_limits_init(struct sr_sw_limits *limits); +/*--- feed_queue.h ----------------------------------------------------------*/ + +struct feed_queue_logic; +struct feed_queue_analog; + +SR_API struct feed_queue_logic *feed_queue_logic_alloc( + const struct sr_dev_inst *sdi, + size_t sample_count, size_t unit_size); +SR_API int feed_queue_logic_submit_one(struct feed_queue_logic *q, + const uint8_t *data, size_t repeat_count); +SR_API int feed_queue_logic_submit_many(struct feed_queue_logic *q, + const uint8_t *data, size_t samples_count); +SR_API int feed_queue_logic_flush(struct feed_queue_logic *q); +SR_API int feed_queue_logic_send_trigger(struct feed_queue_logic *q); +SR_API void feed_queue_logic_free(struct feed_queue_logic *q); + +SR_API struct feed_queue_analog *feed_queue_analog_alloc( + const struct sr_dev_inst *sdi, + size_t sample_count, int digits, struct sr_channel *ch); +SR_API int feed_queue_analog_mq_unit(struct feed_queue_analog *q, + enum sr_mq mq, enum sr_mqflag mq_flag, enum sr_unit unit); +SR_API int feed_queue_analog_scale_offset(struct feed_queue_analog *q, + const struct sr_rational *scale, const struct sr_rational *offset); +SR_API int feed_queue_analog_submit_one(struct feed_queue_analog *q, + float data, size_t repeat_count); +SR_API int feed_queue_analog_flush(struct feed_queue_analog *q); +SR_API void feed_queue_analog_free(struct feed_queue_analog *q); + #endif