X-Git-Url: https://sigrok.org/gitweb/?p=libsigrok.git;a=blobdiff_plain;f=src%2Flibsigrok-internal.h;h=25297f4c9386561d8583494cf9e2c2c75e7cd3f6;hp=9c9da8cd61644df7235af51adc10a5f871f17835;hb=deb7615262ac4f9cc0750a08351afa7cbf9c34d5;hpb=828eeea2270a1858d28fa7492602860c39e4d928 diff --git a/src/libsigrok-internal.h b/src/libsigrok-internal.h index 9c9da8cd..25297f4c 100644 --- a/src/libsigrok-internal.h +++ b/src/libsigrok-internal.h @@ -17,12 +17,6 @@ * along with this program. If not, see . */ -/** - * @file - * - * @internal - */ - #ifndef LIBSIGROK_LIBSIGROK_INTERNAL_H #define LIBSIGROK_LIBSIGROK_INTERNAL_H @@ -62,202 +56,922 @@ 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 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 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 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 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 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 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 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__ @@ -279,7 +993,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 /** @@ -311,6 +1034,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 *)))) \ = { \ @@ -731,6 +1455,9 @@ 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; @@ -744,6 +1471,8 @@ struct sr_serial_dev_inst { 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 *sp_data; @@ -751,6 +1480,9 @@ struct sr_serial_dev_inst { #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; @@ -761,6 +1493,25 @@ struct sr_serial_dev_inst { 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_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; + struct sr_bt_desc *bt_desc; + GSList *bt_source_args; +#endif }; #endif @@ -1009,8 +1760,9 @@ 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); @@ -1060,6 +1812,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); @@ -1079,10 +1837,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); @@ -1120,6 +1881,8 @@ enum { }; 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); @@ -1138,19 +1901,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); @@ -1180,6 +1945,8 @@ struct ser_lib_functions { 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, @@ -1196,12 +1963,13 @@ struct ser_lib_functions { 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; #ifdef HAVE_LIBHIDAPI struct vid_pid_item { uint16_t vid, pid; }; -#define VID_PID_TERM ALL_ZERO struct ser_hid_chip_functions { const char *chipname; @@ -1218,11 +1986,56 @@ struct ser_hid_chip_functions { 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); + +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 + /*--- ezusb.c ---------------------------------------------------------------*/ #ifdef HAVE_LIBUSB_1_0 @@ -1247,6 +2060,91 @@ SR_PRIV gboolean usb_match_manuf_prod(libusb_device *dev, const char *manufacturer, const char *product); #endif +/*--- binary_helpers.c ------------------------------------------------------*/ + +/** Binary value type */ +enum binary_value_type { + BVT_INVALID, + + BVT_UINT8, + BVT_BE_UINT8 = BVT_UINT8, + BVT_LE_UINT8 = BVT_UINT8, + + BVT_BE_UINT16, + BVT_BE_UINT32, + BVT_BE_UINT64, + BVT_BE_FLOAT, + + BVT_LE_UINT16, + BVT_LE_UINT32, + BVT_LE_UINT64, + BVT_LE_FLOAT, +}; + +/** Binary value specification */ +struct binary_value_spec { + /** Offset into binary blob */ + size_t offset; + /** Data type to decode */ + enum binary_value_type type; + /** Scale factor to get native units */ + float scale; +}; + +/** Binary channel definition */ +struct binary_analog_channel { + /** Channel name */ + const char *name; + /** Binary value in data stream */ + struct binary_value_spec spec; + /** Significant digits */ + int digits; + /** Measured quantity */ + enum sr_mq mq; + /** Measured unit */ + enum sr_unit unit; +}; + +/** + * Read extract a value from a binary blob. + * + * @param out Pointer to output buffer. + * @param spec Binary value specification + * @param data Pointer to binary blob + * @param length Size of binary blob + * @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 void *data, size_t length); + +/** + * Send an analog channel packet based on a binary analog channel + * specification. + * + * @param sdi Device instance + * @param ch Sigrok channel + * @param spec Channel specification + * @param data Pointer to binary blob + * @param length Size of binary blob + * @return SR_OK on success, SR_ERR_* error code on failure. + */ +SR_PRIV int bv_send_analog_channel(const struct sr_dev_inst *sdi, struct sr_channel *ch, + const struct binary_analog_channel *spec, const void *data, size_t length); + +/*--- 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 -------------------------------------------------------*/ @@ -1385,6 +2283,16 @@ 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); +/*--- 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 @@ -1497,6 +2405,66 @@ 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); +/*--- 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 @@ -1550,21 +2518,53 @@ SR_PRIV int sr_vc96_parse(const uint8_t *buf, float *floatval, /*--- 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); +/* 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 -----------------------------------------------------------*/ @@ -1641,10 +2641,8 @@ 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); /*--- scale/kern.c ----------------------------------------------------------*/ @@ -1663,19 +2661,48 @@ 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(struct feed_queue_logic *q, + const uint8_t *data, size_t 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_submit(struct feed_queue_analog *q, + float data, size_t 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