X-Git-Url: https://sigrok.org/gitweb/?a=blobdiff_plain;f=src%2Flibsigrok-internal.h;h=db74dcc27e515f04b364c9425b9c5b48a5cb7f9a;hb=d8fbfcd9d6d66bffcb8607e9de7706ce322d42c7;hp=378c86d41d4283a50d55aa0ab1fbbaaefdb5a57f;hpb=d579755a662c7516cf70a38c36e3266e7bdb3ee8;p=libsigrok.git diff --git a/src/libsigrok-internal.h b/src/libsigrok-internal.h index 378c86d4..db74dcc2 100644 --- a/src/libsigrok-internal.h +++ b/src/libsigrok-internal.h @@ -32,6 +32,9 @@ #ifdef HAVE_LIBUSB_1_0 #include #endif +#ifdef HAVE_LIBFTDI +#include +#endif #include #include #include @@ -74,6 +77,16 @@ static inline uint8_t read_u8(const uint8_t *p) } #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 @@ -357,6 +370,28 @@ static inline float read_fltle(const uint8_t *p) } #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 @@ -415,6 +450,19 @@ static inline void write_u16le(uint8_t *p, uint16_t x) } #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 @@ -443,6 +491,54 @@ static inline void write_u32le(uint8_t *p, uint32_t x) } #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 @@ -519,6 +615,23 @@ static inline uint8_t read_u8_inc(const uint8_t **p) 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. @@ -554,17 +667,34 @@ static inline uint16_t read_u16le_inc(const uint8_t **p) } /** - * Read unsigned 32bit integer from raw memory (big endian format), increment read position. + * 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, unsigned. + * @return Retrieved integer value, signed. */ -static inline uint32_t read_u32be_inc(const uint8_t **p) +static inline int16_t read_i16be_inc(const uint8_t **p) { - uint32_t v; + int16_t v; if (!p || !*p) return 0; - v = read_u32be(*p); + 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; @@ -587,6 +717,23 @@ static inline uint32_t read_u24le_inc(const uint8_t **p) 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. @@ -604,6 +751,40 @@ static inline uint32_t read_u32le_inc(const uint8_t **p) 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. @@ -638,6 +819,23 @@ static inline uint64_t read_u64le_inc(const uint8_t **p) 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. @@ -655,6 +853,23 @@ static inline float read_fltle_inc(const uint8_t **p) 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. @@ -711,6 +926,19 @@ static inline void write_u16le_inc(uint8_t **p, uint16_t 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. @@ -737,6 +965,32 @@ static inline void write_u32le_inc(uint8_t **p, uint32_t 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. @@ -784,6 +1038,21 @@ static inline void write_dblle_inc(uint8_t **p, double x) 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 { } */ @@ -799,6 +1068,15 @@ static inline void write_dblle_inc(uint8_t **p, double x) #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 + /** * Register a list of hardware drivers. * @@ -828,6 +1106,7 @@ static inline void write_dblle_inc(uint8_t **p, double x) */ #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 *)))) \ = { \ @@ -1366,6 +1645,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. */ @@ -1404,6 +1688,7 @@ 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 @@ -1608,6 +1893,8 @@ SR_PRIV int std_cg_idx(const struct sr_channel_group *cg, struct sr_channel_grou 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 ------------------------------------------------------------*/ @@ -1629,10 +1916,12 @@ SR_PRIV void *sr_resource_load(struct sr_context *ctx, int type, 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); @@ -1670,6 +1959,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); @@ -1692,17 +1983,17 @@ 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); -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); @@ -1732,6 +2023,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, @@ -1779,6 +2072,9 @@ 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 @@ -1846,7 +2142,9 @@ SR_PRIV gboolean usb_match_manuf_prod(libusb_device *dev, /** Binary value type */ enum binary_value_type { - BVT_UINT8 = 0, + BVT_INVALID, + + BVT_UINT8, BVT_BE_UINT8 = BVT_UINT8, BVT_LE_UINT8 = BVT_UINT8, @@ -2063,6 +2361,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 @@ -2175,6 +2483,52 @@ 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 @@ -2398,6 +2752,9 @@ 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, @@ -2410,15 +2767,16 @@ struct feed_queue_logic; struct feed_queue_analog; SR_API struct feed_queue_logic *feed_queue_logic_alloc( - struct sr_dev_inst *sdi, + 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( - struct sr_dev_inst *sdi, + 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);