2 * This file is part of the libsigrok project.
4 * Copyright (C) 2019-2023 Gerhard Sittig <gerhard.sittig@gmx.net>
6 * This program is free software: you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation, either version 3 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program. If not, see <http://www.gnu.org/licenses/>.
21 * This input module reads data values from an input stream, and sends
22 * the corresponding samples to the sigrok session feed which form the
23 * respective waveform, pretending that a logic analyzer had captured
24 * wire traffic. This allows to feed data to protocol decoders which
25 * were recorded by different means (COM port redirection, pcap(3)
26 * recordings, 3rd party bus analyzers). It can also simplify the
27 * initial creation of protocol decoders by generating synthetic
28 * input data, before real world traffic captures become available.
30 * This input module "assumes ideal traffic" and absence of protocol
31 * errors. Does _not_ inject error conditions, instead generates valid
32 * bit patterns by naively filling blanks to decorate the payload data
33 * which the input file provides. To yield a stream of samples which
34 * successfully decodes at the recipient's, and upper layer decoders
35 * will see valid data which corresponds to the file's content. Edge
36 * positions and minute timnig details are not adjustable either in
37 * this module (no support for setup or hold times or slew rates etc).
38 * The goal is not to emulate a protocol with all its possibilities to
39 * the fullest detail. The module's purpose is to simplify the import
40 * of values while no capture of the wire traffic was available.
42 * There are several approaches to using the input module:
43 * - Input data can be a mere bytes sequence. While attributes can get
44 * specified by means of input module options. This is the fastest
45 * approach to accessing raw data that's externally made available.
46 * - An optional leading magic literal supports automatic file type
47 * detection, and obsoletes the -I input module selection. Unwanted
48 * automatic detection is possible but very unlikely. The magic text
49 * was chosen such that its occurance at the very start of payload
50 * data is extremely unlikely, and is easy to work around should the
51 * situation happen. Of course specifying input module options does
52 * necessitate the selection of the input module.
53 * - When the file type magic is present, an optional header section
54 * can follow, and can carry parameters which obsolete the necessity
55 * to specify input module options. The choice of header section
56 * boundaries again reduces the likelyhood of false detection. When
57 * input module options were specified, they take precedence over
58 * input stream content.
59 * - The payload of the input stream (the protocol values) can take
60 * the form of a mere bytes sequence where every byte is a value
61 * (this is the default). Or values can be represented in textual
62 * format when either an input module option or the header section
63 * specify that the input is text. Individual protocol handlers can
64 * also prefer one format over another, while file content and
65 * module options take precedence as usual. Some protocols may not
66 * usefully be described by values only, or may involve values and
67 * numbers larger than a byte, which essentially makes text format
68 * a non-option for these situations.
69 * - The text format supports coments which silently get discarded.
70 * As well as pseudo comments which can affect the interpretation
71 * of the input text, and/or can control properties of protocols
72 * that exceed the mere submission of values. Think chip-select or
73 * ACK/NAK slots or similar.
74 * - It's understood that the text format is more expensive to process,
75 * but is also more versatile. It's assumed that the 'protocoldata'
76 * input format is used for small or mid size capture lengths. The
77 * input module enables quick access to data that became available
78 * by other means. For higher fidelity of real world traffic and for
79 * long captures the native format should be preferred. For error
80 * injection the VCD format might be a better match.
81 * - It should be obvious that raw bytes or input data in text form,
82 * as well as header fields can either be the content of a file on
83 * disk, or can be part of a pipe input. Either the earlier process
84 * in the pipe which provides the values, or an intermediate filter
85 * in the pipe, can provide the decoration.
86 * $ ./gen-values.sh | sigrok-cli -i - ...
87 * $ ./gen-values.sh | cat header - | sigrok-cli -i - ...
88 * - Since the input format supports automatic detection as well as
89 * parameter specs by means of input module options as well as in
90 * file content, the format lends itself equally well to pipelined
91 * or scripted as well as interactive use in different applications.
92 * For pipelines, the header as well as the values (as well as any
93 * mix of these pieces) can be kept in separate locations. Generators
94 * need not provide all of the input stream in a single invocation.
95 * - As a matter of convenience, especially when targetting upper layer
96 * protocol decoders, users need not construct "correctly configured"
97 * from the lower protocol's perspective) waveforms on the wire.
98 * Instead "naive" waveforms which match the decoders' default options
99 * can be used, which eliminates the need to configure non-default
100 * options in decoders (and redundantly do the same thing in the
101 * input module, just to have them match again).
102 * $ ./gen-values.sh | sigrok-cli \
103 * -i - -I protocoldata:protocol=uart:bitrate=57600:frameformat=8e2 \
104 * -P uart:parity=even:baudrate=57600
105 * $ ./gen-values.sh | sigrok-cli \
106 * -i - -I protocoldata:protocol=uart -P uart,midi
108 * Example invocations:
110 * $ sigrok-cli -I protocoldata --show
112 * $ echo "Hello sigrok protocol values!" | \
114 * -I protocoldata:protocol=uart -i - \
115 * -P uart:format=ascii -A uart=rx-data
117 * $ sigrok-cli -i file.bin -P uart -A uart=rx-data
118 * $ sigrok-cli -i file.txt -P uart:rx=rxtx -A uart
119 * $ sigrok-cli -i file.txt --show
120 * $ sigrok-cli -i file.txt -O ascii:width=4000 | $PAGER
122 * $ echo "# -- sigrok protocol data values file --" > header.txt
123 * $ echo "# -- sigrok protocol data header start --" >> header.txt
124 * $ echo "protocol=uart" >> header.txt
125 * $ echo "bitrate=100000" >> header.txt
126 * $ echo "frameformat=8e2" >> header.txt
127 * $ echo "textinput=yes" >> header.txt
128 * $ echo "# -- sigrok protocol data header end --" >> header.txt
129 * $ echo "# textinput: radix=16" > values.txt
130 * $ echo "0f 40 a6 28 fa 78 05 19 ee c2 92 70 58 62 09 a9 f1 ca 44 90 d1 07 19 02 00" >> values.txt
131 * $ head header.txt values.txt
132 * $ cat values.txt | cat header.txt - | \
133 * sigrok-cli -i - -P uart:baudrate=100000:parity=even,sbus_futaba -A sbus_futaba
135 * $ pulseview -i file-spi-text.txt &
138 * - Only few protocols are implemented so far. Existing handlers have
139 * suggested which infrastructure is required for future extension.
140 * But future handlers may reveal more omissions or assumptions that
142 * - Terminology may be inconsistent, because this input module supports
143 * several protocols which often differ in how they use terms. What is
145 * - The input module constructs waveforms that span multiple traces.
146 * Resulting waveforms are said to have a samplerate. Data that is
147 * kept in that waveform can have a bitrate. Which is essential for
148 * asynchronous communication, but could be unimportant for clocked
149 * protocols. Protocol handlers may adjust their output to enforce
150 * a bitrate, but need not. The timing is an approximation anyway,
151 * does not reflect pauses or jitter or turnarounds which real world
152 * traffic would reveal.
153 * - Protocol handlers can generate an arbitrary number of samples for
154 * a protocol data value. A maximum number of samples per value is
155 * assumed. Variable length samples sequences per data value or per
156 * invocation is supported (and can be considered the typical case).
157 * - Protocol handlers can configure differing widths for the samples
158 * that they derived from input data. These quanta get configured
159 * when the frame format gets interpreted, and are assumed to remain
160 * as they are across data value processing.
161 * - Data values can be considered "a frame" (as seen with UART). But
162 * data values could also be "bytes" or "words" in a protocol, while
163 * "frames" or "transfers" are implemented by different means (as
164 * seen with SPI or I2C). The typical approach would be to control a
165 * "select" signal by means of pseudo comments which are interleaved
167 * - Data values need not get forwarded to decoders. They might also
168 * control the processing of the following data values as well as
169 * the waveform construction. This is at the discretion of protocol
170 * handlers, think of slave addresses, preceeding field or value
171 * counts before their data values follow, etc.
172 * - Users may need to specify more options than expected when the file
173 * content is "incomplete". The sequence of scanning builtin defaults,
174 * then file content provided specs, then user specified specs, is
175 * yet to get done. Until then it helps being explicit and thorough.
177 * TODO (arbitrary order, could partially be outdated)
178 * - Implement the most appropriate order of option scanning. Use
179 * builtin defaults first, file content then, then user specified
180 * options (when available). This shall be most robust and correct.
181 * - Switch to "submit one sample" in feed queue API when available.
182 * The current implementation of this input module uses ugly ifdefs
183 * to adjust to either feed queue API approach.
184 * - (obsoleted by the introduction of support for text format input?)
185 * Introduce TLV support for the binary input format? u32be type,
186 * u64be length, u8[] payload. The complexity of the implementation
187 * in the input module, combined with the complexity of generating
188 * the input stream which uses TLV sections, are currently considered
189 * undesirable for this input module. Do we expect huge files where
190 * the computational cost of text conversion causes pain?
191 * - Extend the UART protocol handler. Implement separate RX and TX
192 * traces. Support tx-only, rx-only, and tx-then-rx input orders.
193 * - Add a 'parallel' protocol handler, which grabs a bit pattern and
194 * derives the waveform in straight forward ways? This would be similar
195 * to the raw binary input module, but the text format could improve
196 * readability, and the input module could generate a clock signal
197 * which isn't part of the input stream. That 'parallel' protocol
198 * could be used as a vehicle to bitbang any other protocol that is
199 * unknown to the input module. The approach is only limited by the
200 * input stream generator's imagination.
201 * - Add other protocol variants. The binary input format was very
202 * limiting, the text format could cover a lot of more cases:
203 * - CAN: Pseudo comments can communicate the frame's flags (and
204 * address type etc). The first data value can be the address. The
205 * second data value or a pseudo comment can hold the CAN frame's
206 * data length (bytes count). Other data values are the 0..8 data
207 * bytes. CAN-FD might be possible with minimal adjustment?
208 * - W1: Pseudo comments can start a frame (initiate RESET). First
209 * value can carry frame length. Data bytes follow. Scans can get
210 * represented as raw bytes (bit count results in full 8bit size).
211 * - Are more than 8 traces desirable? The initial implementation was
212 * motivated by serial communication (UART). More channels were not
213 * needed so far. Even QuadSPI and Hitachi displays fit onto 8 lines.
215 * See the sigrok.org file format wiki page for details about the syntax
216 * that is supported by this input module. Or see the top of the source
217 * file and its preprocessor symbols to quickly get an idea of known
218 * keywords in input files.
224 #include <libsigrok/libsigrok.h>
228 #include "libsigrok-internal.h"
230 #define LOG_PREFIX "input/protocoldata"
232 #define CHUNK_SIZE (4 * 1024 * 1024)
235 * Support optional automatic file type detection. Support optionally
236 * embedded options in a header section after the file detection magic
237 * and before the payload data (bytes or text).
239 #define MAGIC_FILE_TYPE "# -- sigrok protocol data values file --"
240 #define TEXT_HEAD_START "# -- sigrok protocol data header start --"
241 #define TEXT_HEAD_END "# -- sigrok protocol data header end --"
242 #define TEXT_COMM_LEADER "#"
244 #define LABEL_SAMPLERATE "samplerate="
245 #define LABEL_BITRATE "bitrate="
246 #define LABEL_PROTOCOL "protocol="
247 #define LABEL_FRAMEFORMAT "frameformat="
248 #define LABEL_TEXTINPUT "textinput="
251 * Options which are embedded in pseudo comments and are related to
252 * how the input module reads the input text stream. Universally
253 * applicable to all text inputs regardless of protocol choice.
255 #define TEXT_INPUT_PREFIX "textinput:"
256 #define TEXT_INPUT_RADIX "radix="
259 * Protocol dependent frame formats, the default and absolute limits.
260 * Protocol dependent keywords in pseudo-comments.
262 * UART assumes 9x2 as the longest useful frameformat. Additional STOP
263 * bits let users insert idle phases between frames, until more general
264 * support for inter-frame gaps is in place. By default the protocol
265 * handler generously adds a few more idle bit times after a UART frame.
267 * SPI assumes exactly 8 bits per "word". And leaves bit slots around
268 * the byte transmission, to have space where CS asserts or releases.
269 * Including time where SCK changes to its idle level. And requires two
270 * samples per bit time (pos and neg clock phase). The "decoration" also
271 * helps users' interactive exploration of generated waveforms.
273 * I2C generously assumes six quanta per bit slot, to gracefully allow
274 * for reliable SCL and SDA transitions regardless of samples that result
275 * from prior communication. The longest waveform is a byte (with eight
276 * data bits and an ACK slot). Special symbols like START, and STOP will
277 * fit into that memory while it is not used to communicate a byte.
279 #define UART_HANDLER_NAME "uart"
280 #define UART_DFLT_SAMPLERATE SR_MHZ(1)
281 #define UART_DFLT_BITRATE 115200
282 #define UART_DFLT_FRAMEFMT "8n1"
283 #define UART_MIN_DATABITS 5
284 #define UART_MAX_DATABITS 9
285 #define UART_MAX_STOPBITS 20
286 #define UART_ADD_IDLEBITS 2
287 #define UART_MAX_WAVELEN (1 + UART_MAX_DATABITS + 1 + UART_MAX_STOPBITS \
289 #define UART_FORMAT_INVERT "inverted"
290 /* In addition the usual '8n1' et al are supported. */
291 #define UART_PSEUDO_BREAK "break"
292 #define UART_PSEUDO_IDLE "idle"
294 #define SPI_HANDLER_NAME "spi"
295 #define SPI_DFLT_SAMPLERATE SR_MHZ(10)
296 #define SPI_DFLT_BITRATE SR_MHZ(1)
297 #define SPI_DFLT_FRAMEFMT "cs-low,bits=8,mode=0,msb-first"
298 #define SPI_MIN_DATABITS 8
299 #define SPI_MAX_DATABITS 8
300 #define SPI_MAX_WAVELEN (2 + 2 * SPI_MAX_DATABITS + 3)
301 #define SPI_FORMAT_CS_LOW "cs-low"
302 #define SPI_FORMAT_CS_HIGH "cs-high"
303 #define SPI_FORMAT_DATA_BITS "bits="
304 #define SPI_FORMAT_SPI_MODE "mode="
305 #define SPI_FORMAT_MODE_CPOL "cpol="
306 #define SPI_FORMAT_MODE_CPHA "cpha="
307 #define SPI_FORMAT_MSB_FIRST "msb-first"
308 #define SPI_FORMAT_LSB_FIRST "lsb-first"
309 #define SPI_PSEUDO_MOSI_ONLY "mosi-only"
310 #define SPI_PSEUDO_MOSI_FIXED "mosi-fixed="
311 #define SPI_PSEUDO_MISO_ONLY "miso-only"
312 #define SPI_PSEUDO_MISO_FIXED "miso-fixed="
313 #define SPI_PSEUDO_MOSI_MISO "mosi-then-miso"
314 #define SPI_PSEUDO_MISO_MOSI "miso-then-mosi"
315 #define SPI_PSEUDO_CS_ASSERT "cs-assert"
316 #define SPI_PSEUDO_CS_RELEASE "cs-release"
317 #define SPI_PSEUDO_CS_NEXT "cs-auto-next="
318 #define SPI_PSEUDO_IDLE "idle"
320 #define I2C_HANDLER_NAME "i2c"
321 #define I2C_DFLT_SAMPLERATE SR_MHZ(10)
322 #define I2C_DFLT_BITRATE SR_KHZ(400)
323 #define I2C_DFLT_FRAMEFMT "addr-7bit"
324 #define I2C_BITTIME_SLOTS (1 + 8 + 1 + 1)
325 #define I2C_BITTIME_QUANTA 6
326 #define I2C_ADD_IDLESLOTS 2
327 #define I2C_MAX_WAVELEN (I2C_BITTIME_QUANTA * I2C_BITTIME_SLOTS + I2C_ADD_IDLESLOTS)
328 #define I2C_FORMAT_ADDR_7BIT "addr-7bit"
329 #define I2C_FORMAT_ADDR_10BIT "addr-10bit"
330 #define I2C_PSEUDO_START "start"
331 #define I2C_PSEUDO_REP_START "repeat-start"
332 #define I2C_PSEUDO_STOP "stop"
333 #define I2C_PSEUDO_ADDR_WRITE "addr-write="
334 #define I2C_PSEUDO_ADDR_READ "addr-read="
335 #define I2C_PSEUDO_ACK_NEXT "ack-next="
336 #define I2C_PSEUDO_ACK_ONCE "ack-next"
344 static const char *input_format_texts[] = {
345 [INPUT_UNSPEC] = "from-file",
346 [INPUT_BYTES] = "raw-bytes",
347 [INPUT_TEXT] = "text-format",
350 struct spi_proto_context_t {
351 gboolean needs_mosi, has_mosi;
352 gboolean needs_miso, has_miso;
355 size_t auto_cs_remain;
356 uint8_t mosi_byte, miso_byte;
357 uint8_t mosi_fixed_value;
358 gboolean mosi_is_fixed;
359 uint8_t miso_fixed_value;
360 gboolean miso_is_fixed;
363 struct i2c_proto_context_t {
369 struct proto_handler_t {
374 const char *frame_format;
375 enum textinput_t textinput;
382 int (*check_opts)(struct context *inc);
383 int (*config_frame)(struct context *inc);
384 int (*proc_pseudo)(struct sr_input *in, char *text);
385 int (*proc_value)(struct context *inc, uint32_t value);
386 int (*get_idle_capture)(struct context *inc,
387 size_t *bits, uint8_t *lvls);
388 int (*get_idle_interframe)(struct context *inc,
389 size_t *samples, uint8_t *lvls);
393 /* User provided options. */
397 const char *proto_name;
398 const char *fmt_text;
399 enum textinput_t textinput;
401 /* Derived at runtime. */
405 uint64_t samples_per_bit;
408 enum textinput_t textinput;
416 const struct proto_handler_t *prot_hdl;
419 struct uart_frame_fmt_opts {
420 size_t databit_count;
426 size_t stopbit_count;
427 gboolean half_stopbit;
430 struct spi_frame_fmt_opts {
432 size_t databit_count;
434 gboolean spi_mode_cpol;
435 gboolean spi_mode_cpha;
437 struct i2c_frame_fmt_opts {
442 /* Module stage. Logic output channels. Session feed. */
443 gboolean scanned_magic;
449 size_t channel_count;
450 const char **channel_names;
451 struct feed_queue_logic *feed_logic;
453 * Internal state: Allocated space for a theoretical maximum
454 * bit count. Filled in bit pattern for the current data value.
455 * (Stuffing can result in varying bit counts across frames.)
457 * Keep the bits' width in sample numbers, as well as the bits'
458 * boundaries relative to the start of the protocol frame's
459 * start. Support a number of logic bits per bit time.
461 * Implementor's note: Due to development history terminology
462 * might slip here. Strictly speaking it's "waveform sections"
463 * that hold samples for a given number of cycles. "A bit" in
464 * the protocol can occupy multiple of these slots to e.g. have
465 * a synchronous clock, or to present setup and hold phases,
466 * etc. Sample data spans several logic signal traces. You get
469 size_t max_frame_bits; /* Reserved. */
470 size_t top_frame_bits; /* Currently filled. */
474 } *bit_scale; /* Quanta scaling. */
475 size_t *sample_edges;
476 size_t *sample_widths;
477 uint8_t *sample_levels; /* Sample data, logic traces. */
478 /* Common support for samples updating by manipulation. */
483 /* Internal state of the input text reader. */
487 /* Manage state across .reset() calls. Robustness. */
494 /* {{{ frame bits manipulation, waveform construction */
497 * Primitives to construct waveforms for a protocol frame, by sequencing
498 * samples after data values were seen in the input stream. Individual
499 * protocol handlers will use these common routines.
501 * The general idea is: The protocol handler's options parser determines
502 * the frame format, and derives the maximum number of time slots needed
503 * to represent the waveform. Slots can scale differintly, proportions
504 * get configured once during initialization. All remaining operation
505 * receives arbitrarily interleaved data values and pseudo comments, uses
506 * the pre-allocated and pre-scaled time slots to construct waveforms,
507 * which then get sent to the session bus as if an acquisition device
508 * had captured wire traffic. For clocked signals the "coarse" timing
509 * should never be an issue. Protocol handlers are free to use as many
510 * time slots per bit time as they please or feel necessary.
513 static int alloc_frame_storage(struct context *inc)
520 if (!inc->max_frame_bits)
523 inc->top_frame_bits = 0;
524 bits = inc->max_frame_bits;
526 alloc = bits * sizeof(inc->sample_edges[0]);
527 inc->sample_edges = g_malloc0(alloc);
528 alloc = bits * sizeof(inc->sample_widths[0]);
529 inc->sample_widths = g_malloc0(alloc);
530 alloc = bits * sizeof(inc->sample_levels[0]);
531 inc->sample_levels = g_malloc0(alloc);
532 if (!inc->sample_edges || !inc->sample_widths || !inc->sample_levels)
533 return SR_ERR_MALLOC;
535 alloc = bits * sizeof(inc->bit_scale[0]);
536 inc->bit_scale = g_malloc0(alloc);
538 return SR_ERR_MALLOC;
544 * Assign an equal bit width to all bits in the frame. Derive the width
545 * from the bitrate and the sampelrate. Protocol handlers optionally can
546 * arrange for "odd bit widths" (either fractions, or multiples, or when
547 * desired any rational at all). Think half-bits, or think quanta within
548 * a bit time, depends on the protocol handler really.
550 * Implementation note: The input module assumes that the position of
551 * odd length bits will never vary during frame construction. The total
552 * length may vary, 'top' can be smaller than 'max' in every iteration.
553 * It is assumed that frames with odd-length bits have constant layout,
554 * and that stuffing protocols have same-width bits. Odd lengths also
555 * can support bit time quanta, while it's assumed that these always use
556 * the same layout for all generated frames. This constraint is kept in
557 * the implementation, until one of the supported protocols genuinely
558 * requires higher flexibility and the involved complexity and runtime
559 * cost of per-samplepoint adjustment.
561 static int assign_bit_widths(struct context *inc)
563 const struct proto_handler_t *handler;
565 double bit_edge, bit_time, this_bit_time;
566 uint64_t bit_time_int, bit_time_prev, bit_times_total;
573 * Run the protocol handler's optional configure routine.
574 * It derives the maximum number of "bit slots" that are needed
575 * to represent a protocol frame's waveform.
577 handler = inc->curr_opts.prot_hdl;
578 if (handler && handler->config_frame) {
579 ret = handler->config_frame(inc);
584 /* Assign bit widths to the protocol frame's bit positions. */
585 bit_time = inc->curr_opts.samplerate;
586 bit_time /= inc->curr_opts.bitrate;
587 inc->curr_opts.samples_per_bit = bit_time + 0.5;
588 sr_dbg("Samplerate %" PRIu64 ", bitrate %" PRIu64 ".",
589 inc->curr_opts.samplerate, inc->curr_opts.bitrate);
590 sr_dbg("Resulting bit width %.2f samples, int %" PRIu64 ".",
591 bit_time, inc->curr_opts.samples_per_bit);
595 for (idx = 0; idx < inc->max_frame_bits; idx++) {
596 this_bit_time = bit_time;
597 if (inc->bit_scale[idx].mul)
598 this_bit_time *= inc->bit_scale[idx].mul;
599 if (inc->bit_scale[idx].div)
600 this_bit_time /= inc->bit_scale[idx].div;
601 bit_edge += this_bit_time;
602 bit_time_int = (uint64_t)(bit_edge + 0.5);
603 inc->sample_edges[idx] = bit_time_int;
604 bit_time_int -= bit_time_prev;
605 inc->sample_widths[idx] = bit_time_int;
606 bit_time_prev = inc->sample_edges[idx];
607 bit_times_total += bit_time_int;
608 sr_spew("Bit %zu, width %" PRIu64 ".", idx, bit_time_int);
610 sr_dbg("Maximum waveform width: %zu slots, %.2f / %zu samples.",
611 inc->max_frame_bits, bit_edge, bit_times_total);
616 /* Start accumulating the samples for a new part of the waveform. */
617 static int wave_clear_sequence(struct context *inc)
623 inc->top_frame_bits = 0;
628 /* Append channels' levels to the waveform for another period of samples. */
629 static int wave_append_pattern(struct context *inc, uint8_t sample)
635 if (inc->top_frame_bits >= inc->max_frame_bits)
638 inc->sample_levels[inc->top_frame_bits++] = sample;
643 /* Initially assign idle levels, start the buffer from idle state. */
644 static void sample_buffer_preset(struct context *inc, uint8_t idle_sample)
646 inc->samples.idle_levels = idle_sample;
647 inc->samples.curr_levels = idle_sample;
650 /* Modify the samples buffer by assigning a given traces state. */
651 static void sample_buffer_assign(struct context *inc, uint8_t sample)
653 inc->samples.curr_levels = sample;
656 /* Modify the samples buffer by changing individual traces. */
657 static void sample_buffer_modify(struct context *inc,
658 uint8_t set_mask, uint8_t clr_mask)
660 inc->samples.curr_levels |= set_mask;
661 inc->samples.curr_levels &= ~clr_mask;
664 static void sample_buffer_raise(struct context *inc, uint8_t bits)
666 return sample_buffer_modify(inc, bits, 0);
669 static void sample_buffer_clear(struct context *inc, uint8_t bits)
671 return sample_buffer_modify(inc, 0, bits);
674 static void sample_buffer_setclr(struct context *inc,
675 gboolean level, uint8_t mask)
678 sample_buffer_raise(inc, mask);
680 sample_buffer_clear(inc, mask);
683 static void sample_buffer_toggle(struct context *inc, uint8_t mask)
685 inc->samples.curr_levels ^= mask;
688 /* Reset current sample buffer to idle state. */
689 static void sample_buffer_toidle(struct context *inc)
691 inc->samples.curr_levels = inc->samples.idle_levels;
694 /* Append the buffered samples to the waveform memory. */
695 static int wave_append_buffer(struct context *inc)
697 return wave_append_pattern(inc, inc->samples.curr_levels);
700 /* Send idle level before the first generated frame and at end of capture. */
701 static int send_idle_capture(struct context *inc)
703 const struct proto_handler_t *handler;
708 handler = inc->curr_opts.prot_hdl;
709 if (!handler->get_idle_capture)
712 ret = handler->get_idle_capture(inc, &count, &data);
715 count *= inc->curr_opts.samples_per_bit;
717 ret = feed_queue_logic_submit_one(inc->feed_logic,
718 &data, sizeof(data));
726 /* Optionally send idle level between protocol frames. */
727 static int send_idle_interframe(struct context *inc)
729 const struct proto_handler_t *handler;
734 handler = inc->curr_opts.prot_hdl;
735 if (!handler->get_idle_interframe)
738 ret = handler->get_idle_interframe(inc, &count, &data);
742 ret = feed_queue_logic_submit_one(inc->feed_logic,
743 &data, sizeof(data));
751 /* Forward the previously accumulated samples of the waveform. */
752 static int send_frame(struct sr_input *in)
760 for (index = 0; index < inc->top_frame_bits; index++) {
761 data = inc->sample_levels[index];
762 count = inc->sample_widths[index];
764 feed_queue_logic_submit_one(inc->feed_logic,
765 &data, sizeof(data));
772 /* }}} frame bits manipulation */
773 /* {{{ UART protocol handler */
779 #define UART_PINMASK_RXTX (1UL << UART_PIN_RXTX)
781 /* UART specific options and frame format check. */
782 static int uart_check_opts(struct context *inc)
784 struct uart_frame_fmt_opts *fmt_opts;
785 const char *fmt_text;
787 size_t opt_count, opt_idx;
796 fmt_opts = &inc->curr_opts.frame_format.uart;
798 /* Apply defaults before reading external spec. */
799 memset(fmt_opts, 0, sizeof(*fmt_opts));
800 fmt_opts->databit_count = 8;
801 fmt_opts->parity_type = UART_PARITY_NONE;
802 fmt_opts->stopbit_count = 1;
803 fmt_opts->half_stopbit = FALSE;
804 fmt_opts->inverted = FALSE;
806 /* Provide a default UART frame format. */
807 fmt_text = inc->curr_opts.fmt_text;
808 if (!fmt_text || !*fmt_text)
809 fmt_text = UART_DFLT_FRAMEFMT;
810 sr_dbg("UART frame format: %s.", fmt_text);
812 /* Parse the comma separated list of user provided options. */
813 opts = g_strsplit_set(fmt_text, ", ", 0);
814 opt_count = g_strv_length(opts);
815 for (opt_idx = 0; opt_idx < opt_count; opt_idx++) {
819 sr_spew("UART format option: %s", opt);
821 * Check for specific keywords. Before falling back to
822 * attempting the "8n1" et al interpretation.
824 if (strcmp(opt, UART_FORMAT_INVERT) == 0) {
825 fmt_opts->inverted = TRUE;
828 /* Parse an "8n1", "8e2", "7o1", or similar input spec. */
829 /* Get the data bits count. */
831 ret = sr_atoul_base(opt, &v, &endp, 10);
832 if (ret != SR_OK || !endp)
835 if (v < UART_MIN_DATABITS || v > UART_MAX_DATABITS)
837 fmt_opts->databit_count = v;
838 /* Get the parity type. */
839 par_text = tolower((int)*opt++);
842 fmt_opts->parity_type = UART_PARITY_NONE;
845 fmt_opts->parity_type = UART_PARITY_ODD;
848 fmt_opts->parity_type = UART_PARITY_EVEN;
853 /* Get the stop bits count. Supports half bits too. */
855 ret = sr_atoul_base(opt, &v, &endp, 10);
856 if (ret != SR_OK || !endp)
859 if (v > UART_MAX_STOPBITS)
861 fmt_opts->stopbit_count = v;
862 if (g_ascii_strcasecmp(opt, ".5") == 0) {
864 fmt_opts->half_stopbit = TRUE;
866 /* Incomplete consumption of input text is fatal. */
868 sr_err("Unprocessed frame format remainder: %s.", opt);
876 * Calculate the total number of bit times in the UART frame.
877 * Add a few more bit times to the reserved space. They usually
878 * are not occupied during data transmission, but are useful to
879 * have for special symbols (BREAK, IDLE).
881 total_bits = 1; /* START bit, unconditional. */
882 total_bits += fmt_opts->databit_count;
883 total_bits += (fmt_opts->parity_type != UART_PARITY_NONE) ? 1 : 0;
884 total_bits += fmt_opts->stopbit_count;
885 total_bits += fmt_opts->half_stopbit ? 1 : 0;
886 total_bits += UART_ADD_IDLEBITS;
887 sr_dbg("UART frame: total bits %lu.", total_bits);
888 if (total_bits > UART_MAX_WAVELEN)
890 inc->max_frame_bits = total_bits;
896 * Configure the frame's bit widths when not identical across the
897 * complete frame. Think half STOP bits.
898 * Preset the sample data for an idle bus.
900 static int uart_config_frame(struct context *inc)
902 struct uart_frame_fmt_opts *fmt_opts;
908 fmt_opts = &inc->curr_opts.frame_format.uart;
911 * Position after the START bit. Advance over DATA, PARITY and
912 * (full) STOP bits. Then set the trailing STOP bit to half if
913 * needed. Make the trailing IDLE period after a UART frame
914 * wider than regular bit times. Add an even wider IDLE period
915 * which is used for special symbols.
918 bit_idx += fmt_opts->databit_count;
919 bit_idx += (fmt_opts->parity_type == UART_PARITY_NONE) ? 0 : 1;
920 bit_idx += fmt_opts->stopbit_count;
921 if (fmt_opts->half_stopbit) {
922 sr_dbg("Setting bit index %zu to half width.", bit_idx);
923 inc->bit_scale[bit_idx].div = 2;
926 inc->bit_scale[bit_idx++].mul = 2;
927 inc->bit_scale[bit_idx++].mul = 4;
929 /* Start from idle signal levels (high when not inverted). */
931 if (!fmt_opts->inverted)
932 sample |= UART_PINMASK_RXTX;
933 sample_buffer_preset(inc, sample);
938 /* Create samples for a special UART frame (IDLE, BREAK). */
939 static int uart_write_special(struct context *inc, uint8_t level)
941 struct uart_frame_fmt_opts *fmt_opts;
947 fmt_opts = &inc->curr_opts.frame_format.uart;
949 ret = wave_clear_sequence(inc);
954 * Set the same level for all bit slots, covering all of
955 * START and DATA (and PARITY) and STOP. This allows the
956 * simulation of BREAK and IDLE phases.
958 if (fmt_opts->inverted)
960 sample_buffer_setclr(inc, level, UART_PINMASK_RXTX);
961 bits = 1; /* START */
962 bits += fmt_opts->databit_count;
963 bits += (fmt_opts->parity_type != UART_PARITY_NONE) ? 1 : 0;
964 bits += fmt_opts->stopbit_count;
965 bits += fmt_opts->half_stopbit ? 1 : 0;
967 ret = wave_append_buffer(inc);
973 * Force a few more idle bit times. This does not affect a
974 * caller requested IDLE symbol. But helps separate (i.e.
975 * robustly detect) several caller requested BREAK symbols.
976 * Also separates those specials from subsequent data bytes.
978 sample_buffer_toidle(inc);
979 bits = UART_ADD_IDLEBITS;
981 ret = wave_append_buffer(inc);
989 /* Process UART protocol specific pseudo comments. */
990 static int uart_proc_pseudo(struct sr_input *in, char *line)
999 word = sr_text_next_word(line, &line);
1004 if (strcmp(word, UART_PSEUDO_BREAK) == 0) {
1005 ret = uart_write_special(inc, 0);
1008 ret = send_frame(in);
1013 if (strcmp(word, UART_PSEUDO_IDLE) == 0) {
1014 ret = uart_write_special(inc, 1);
1017 ret = send_frame(in);
1029 * Create the UART frame's waveform for the given data value.
1031 * In theory the protocol handler could setup START and STOP once during
1032 * initialization. But the overhead compares to DATA and PARITY is small.
1033 * And unconditional START/STOP would break the creation of BREAK and
1034 * IDLE frames, or complicate their construction and recovery afterwards.
1035 * A future implementation might as well support UART traffic on multiple
1036 * traces, including interleaved bidirectional communication. So let's
1037 * keep the implementation simple. Execution time is not a priority.
1039 static int uart_proc_value(struct context *inc, uint32_t value)
1041 struct uart_frame_fmt_opts *fmt_opts;
1044 int par_bit, data_bit;
1048 fmt_opts = &inc->curr_opts.frame_format.uart;
1050 ret = wave_clear_sequence(inc);
1054 /* START bit, unconditional, always 0. */
1055 sample_buffer_clear(inc, UART_PINMASK_RXTX);
1056 if (fmt_opts->inverted)
1057 sample_buffer_toggle(inc, UART_PINMASK_RXTX);
1058 ret = wave_append_buffer(inc);
1060 /* DATA bits. Track parity here (unconditionally). */
1062 bits = fmt_opts->databit_count;
1064 data_bit = value & 0x01;
1066 par_bit ^= data_bit;
1067 if (fmt_opts->inverted)
1068 data_bit = !data_bit;
1069 sample_buffer_setclr(inc, data_bit, UART_PINMASK_RXTX);
1070 ret = wave_append_buffer(inc);
1075 /* PARITY bit. Emission is optional. */
1076 switch (fmt_opts->parity_type) {
1077 case UART_PARITY_ODD:
1078 data_bit = par_bit ? 0 : 1;
1081 case UART_PARITY_EVEN:
1082 data_bit = par_bit ? 1 : 0;
1091 if (fmt_opts->inverted)
1092 data_bit = !data_bit;
1093 sample_buffer_setclr(inc, data_bit, UART_PINMASK_RXTX);
1094 ret = wave_append_buffer(inc);
1099 /* STOP bits. Optional. */
1100 sample_buffer_raise(inc, UART_PINMASK_RXTX);
1101 if (fmt_opts->inverted)
1102 sample_buffer_toggle(inc, UART_PINMASK_RXTX);
1103 bits = fmt_opts->stopbit_count;
1104 bits += fmt_opts->half_stopbit ? 1 : 0;
1106 ret = wave_append_buffer(inc);
1112 * Force some idle time after the UART frame.
1113 * A little shorter than for special symbols.
1115 sample_buffer_toidle(inc);
1116 bits = UART_ADD_IDLEBITS - 1;
1118 ret = wave_append_buffer(inc);
1126 /* Start/end the logic trace with a few bit times of idle level. */
1127 static int uart_get_idle_capture(struct context *inc,
1128 size_t *bitcount, uint8_t *sample)
1131 /* Describe a UART frame's length of idle level. */
1133 *bitcount = inc->max_frame_bits;
1135 *sample = inc->samples.idle_levels;
1139 /* Arrange for a few samples of idle level between UART frames. */
1140 static int uart_get_idle_interframe(struct context *inc,
1141 size_t *samplecount, uint8_t *sample)
1147 * Regular waveform creation for UART frames already includes
1148 * padding between UART frames. That is why we don't need to
1149 * add extra inter-frame samples. Yet prepare the implementation
1150 * for when we need or want to add a few more idle samples.
1153 *samplecount = inc->curr_opts.samples_per_bit;
1157 *sample = inc->samples.idle_levels;
1161 /* }}} UART protocol handler */
1162 /* {{{ SPI protocol handler */
1172 #define SPI_PINMASK_SCK (1UL << SPI_PIN_SCK)
1173 #define SPI_PINMASK_MISO (1UL << SPI_PIN_MISO)
1174 #define SPI_PINMASK_MOSI (1UL << SPI_PIN_MOSI)
1175 #define SPI_PINMASK_CS (1UL << SPI_PIN_CS)
1177 /* "Forget" data which was seen before. */
1178 static void spi_value_discard_prev_data(struct context *inc)
1180 struct spi_proto_context_t *incs;
1182 incs = inc->curr_opts.prot_priv;
1183 incs->has_mosi = !incs->needs_mosi;
1184 incs->has_miso = !incs->needs_miso;
1185 incs->mosi_byte = 0;
1186 incs->miso_byte = 0;
1189 /* Check whether all required values for the byte time were seen. */
1190 static gboolean spi_value_is_bytes_complete(struct context *inc)
1192 struct spi_proto_context_t *incs;
1194 incs = inc->curr_opts.prot_priv;
1196 return incs->has_mosi && incs->has_miso;
1199 /* Arrange for data reception before waveform emission. */
1200 static void spi_pseudo_data_order(struct context *inc,
1201 gboolean needs_mosi, gboolean needs_miso, gboolean mosi_first)
1203 struct spi_proto_context_t *incs;
1205 incs = inc->curr_opts.prot_priv;
1207 incs->needs_mosi = needs_mosi;
1208 incs->needs_miso = needs_miso;
1209 incs->mosi_first = mosi_first;
1211 incs->mosi_is_fixed = FALSE;
1213 incs->miso_is_fixed = FALSE;
1214 spi_value_discard_prev_data(inc);
1217 static void spi_pseudo_mosi_fixed(struct context *inc, uint8_t v)
1219 struct spi_proto_context_t *incs;
1221 incs = inc->curr_opts.prot_priv;
1223 incs->mosi_fixed_value = v;
1224 incs->mosi_is_fixed = TRUE;
1227 static void spi_pseudo_miso_fixed(struct context *inc, uint8_t v)
1229 struct spi_proto_context_t *incs;
1231 incs = inc->curr_opts.prot_priv;
1233 incs->miso_fixed_value = v;
1234 incs->miso_is_fixed = TRUE;
1237 /* Explicit CS control. Arrange for next CS level, track state to keep it. */
1238 static void spi_pseudo_select_control(struct context *inc, gboolean cs_active)
1240 struct spi_frame_fmt_opts *fmt_opts;
1241 struct spi_proto_context_t *incs;
1242 uint8_t cs_level, sck_level;
1244 fmt_opts = &inc->curr_opts.frame_format.spi;
1245 incs = inc->curr_opts.prot_priv;
1247 /* Track current "CS active" state. */
1248 incs->cs_active = cs_active;
1249 incs->auto_cs_remain = 0;
1251 /* Derive current "CS pin level". Update sample data buffer. */
1252 cs_level = 1 - fmt_opts->cs_polarity;
1253 if (incs->cs_active)
1254 cs_level = fmt_opts->cs_polarity;
1255 sample_buffer_setclr(inc, cs_level, SPI_PINMASK_CS);
1257 /* Derive the idle "SCK level" from the SPI mode's CPOL. */
1258 sck_level = fmt_opts->spi_mode_cpol ? 1 : 0;
1259 sample_buffer_setclr(inc, sck_level, SPI_PINMASK_SCK);
1262 /* Arrange for automatic CS release after transfer length. Starts the phase. */
1263 static void spi_pseudo_auto_select(struct context *inc, size_t length)
1265 struct spi_frame_fmt_opts *fmt_opts;
1266 struct spi_proto_context_t *incs;
1269 fmt_opts = &inc->curr_opts.frame_format.spi;
1270 incs = inc->curr_opts.prot_priv;
1272 /* Track current "CS active" state. */
1273 incs->cs_active = TRUE;
1274 incs->auto_cs_remain = length;
1276 /* Derive current "CS pin level". Update sample data buffer. */
1277 cs_level = 1 - fmt_opts->cs_polarity;
1278 if (incs->cs_active)
1279 cs_level = fmt_opts->cs_polarity;
1280 sample_buffer_setclr(inc, cs_level, SPI_PINMASK_CS);
1283 /* Check for automatic CS release. Decrements, yields result. No action here. */
1284 static gboolean spi_auto_select_ends(struct context *inc)
1286 struct spi_proto_context_t *incs;
1288 incs = inc->curr_opts.prot_priv;
1289 if (!incs->auto_cs_remain)
1292 incs->auto_cs_remain--;
1293 if (incs->auto_cs_remain)
1297 * DON'T release CS yet. The last data is yet to get sent.
1298 * Keep the current "CS pin level", but tell the caller that
1299 * CS will be released after transmission of that last data.
1304 /* Update for automatic CS release after last data was sent. */
1305 static void spi_auto_select_update(struct context *inc)
1307 struct spi_frame_fmt_opts *fmt_opts;
1308 struct spi_proto_context_t *incs;
1311 fmt_opts = &inc->curr_opts.frame_format.spi;
1312 incs = inc->curr_opts.prot_priv;
1314 /* Track current "CS active" state. */
1315 incs->cs_active = FALSE;
1316 incs->auto_cs_remain = 0;
1318 /* Derive current "CS pin level". Map to bits pattern. */
1319 cs_level = 1 - fmt_opts->cs_polarity;
1320 sample_buffer_setclr(inc, cs_level, SPI_PINMASK_CS);
1324 * Create the waveforms for one SPI byte. Also cover idle periods:
1325 * Dummy/padding bytes within a frame with clock. Idle lines outside
1326 * of frames without clock edges. Optional automatic CS release with
1327 * resulting inter-frame gap.
1329 static int spi_write_frame_patterns(struct context *inc,
1330 gboolean idle, gboolean cs_release)
1332 struct spi_proto_context_t *incs;
1333 struct spi_frame_fmt_opts *fmt_opts;
1335 uint8_t mosi_bit, miso_bit;
1340 incs = inc->curr_opts.prot_priv;
1341 fmt_opts = &inc->curr_opts.frame_format.spi;
1343 /* Apply fixed values before drawing the waveform. */
1344 if (incs->mosi_is_fixed)
1345 incs->mosi_byte = incs->mosi_fixed_value;
1346 if (incs->miso_is_fixed)
1347 incs->miso_byte = incs->miso_fixed_value;
1349 ret = wave_clear_sequence(inc);
1353 /* Provide two samples with idle SCK and current CS. */
1354 ret = wave_append_buffer(inc);
1357 ret = wave_append_buffer(inc);
1362 * Provide two samples per DATABIT time slot. Keep CS as is.
1363 * Toggle SCK according to CPHA specs. Shift out MOSI and MISO
1364 * in the configured order.
1366 * Force dummy MOSI/MISO bits for idle bytes within a frame.
1367 * Skip SCK toggling for idle "frames" outside of active CS.
1369 bits = fmt_opts->databit_count;
1372 * First half-period. Provide next DATABIT values.
1373 * Toggle SCK here when CPHA is set.
1375 if (fmt_opts->msb_first) {
1376 mosi_bit = incs->mosi_byte & 0x80;
1377 miso_bit = incs->miso_byte & 0x80;
1378 incs->mosi_byte <<= 1;
1379 incs->miso_byte <<= 1;
1381 mosi_bit = incs->mosi_byte & 0x01;
1382 miso_bit = incs->miso_byte & 0x01;
1383 incs->mosi_byte >>= 1;
1384 incs->miso_byte >>= 1;
1386 if (incs->cs_active && !idle) {
1387 sample_buffer_setclr(inc, mosi_bit, SPI_PINMASK_MOSI);
1388 sample_buffer_setclr(inc, miso_bit, SPI_PINMASK_MISO);
1390 if (fmt_opts->spi_mode_cpha && incs->cs_active)
1391 sample_buffer_toggle(inc, SPI_PINMASK_SCK);
1392 ret = wave_append_buffer(inc);
1395 /* Second half-period. Keep DATABIT, toggle SCK. */
1396 if (incs->cs_active)
1397 sample_buffer_toggle(inc, SPI_PINMASK_SCK);
1398 ret = wave_append_buffer(inc);
1401 /* Toggle SCK again unless done above due to CPHA. */
1402 if (!fmt_opts->spi_mode_cpha && incs->cs_active)
1403 sample_buffer_toggle(inc, SPI_PINMASK_SCK);
1407 * Hold the waveform for another sample period. Happens to
1408 * also communicate the most recent SCK pin level.
1410 * Optionally auto-release the CS signal after sending the
1411 * last data byte. Update the CS trace's level. Add another
1412 * (long) bit slot to present an inter-frame gap.
1414 ret = wave_append_buffer(inc);
1418 spi_auto_select_update(inc);
1419 ret = wave_append_buffer(inc);
1423 ret = wave_append_buffer(inc);
1431 /* SPI specific options and frame format check. */
1432 static int spi_check_opts(struct context *inc)
1434 struct spi_frame_fmt_opts *fmt_opts;
1435 const char *fmt_text;
1437 size_t opt_count, opt_idx;
1445 fmt_opts = &inc->curr_opts.frame_format.spi;
1447 /* Setup defaults before reading external specs. */
1448 fmt_opts->cs_polarity = 0;
1449 fmt_opts->databit_count = SPI_MIN_DATABITS;
1450 fmt_opts->msb_first = TRUE;
1451 fmt_opts->spi_mode_cpol = FALSE;
1452 fmt_opts->spi_mode_cpha = FALSE;
1454 /* Provide a default SPI frame format. */
1455 fmt_text = inc->curr_opts.fmt_text;
1456 if (!fmt_text || !*fmt_text)
1457 fmt_text = SPI_DFLT_FRAMEFMT;
1458 sr_dbg("SPI frame format: %s.", fmt_text);
1460 /* Accept comma separated key=value pairs of specs. */
1461 opts = g_strsplit_set(fmt_text, ", ", 0);
1462 opt_count = g_strv_length(opts);
1463 for (opt_idx = 0; opt_idx < opt_count; opt_idx++) {
1464 opt = opts[opt_idx];
1467 sr_spew("SPI format option: %s.", opt);
1468 if (strcmp(opt, SPI_FORMAT_CS_LOW) == 0) {
1469 sr_spew("SPI chip select: low.");
1470 fmt_opts->cs_polarity = 0;
1473 if (strcmp(opt, SPI_FORMAT_CS_HIGH) == 0) {
1474 sr_spew("SPI chip select: high.");
1475 fmt_opts->cs_polarity = 1;
1478 if (g_str_has_prefix(opt, SPI_FORMAT_DATA_BITS)) {
1479 opt += strlen(SPI_FORMAT_DATA_BITS);
1481 ret = sr_atoul_base(opt, &v, &endp, 10);
1486 sr_spew("SPI word size: %lu.", v);
1487 if (v < SPI_MIN_DATABITS || v > SPI_MAX_DATABITS)
1489 fmt_opts->databit_count = v;
1492 if (g_str_has_prefix(opt, SPI_FORMAT_SPI_MODE)) {
1493 opt += strlen(SPI_FORMAT_SPI_MODE);
1495 ret = sr_atoul_base(opt, &v, &endp, 10);
1500 sr_spew("SPI mode: %lu.", v);
1503 fmt_opts->spi_mode_cpol = v & (1UL << 1);
1504 fmt_opts->spi_mode_cpha = v & (1UL << 0);
1507 if (g_str_has_prefix(opt, SPI_FORMAT_MODE_CPOL)) {
1508 opt += strlen(SPI_FORMAT_MODE_CPOL);
1510 ret = sr_atoul_base(opt, &v, &endp, 10);
1515 sr_spew("SPI cpol: %lu.", v);
1518 fmt_opts->spi_mode_cpol = !!v;
1521 if (g_str_has_prefix(opt, SPI_FORMAT_MODE_CPHA)) {
1522 opt += strlen(SPI_FORMAT_MODE_CPHA);
1524 ret = sr_atoul_base(opt, &v, &endp, 10);
1529 sr_spew("SPI cpha: %lu.", v);
1532 fmt_opts->spi_mode_cpha = !!v;
1535 if (strcmp(opt, SPI_FORMAT_MSB_FIRST) == 0) {
1536 sr_spew("SPI endianess: MSB first.");
1537 fmt_opts->msb_first = 1;
1540 if (strcmp(opt, SPI_FORMAT_LSB_FIRST) == 0) {
1541 sr_spew("SPI endianess: LSB first.");
1542 fmt_opts->msb_first = 0;
1550 * Get the total bit count. Add slack for CS control, and to
1551 * visually separate bytes in frames. Multiply data bit count
1552 * for the creation of two clock half-periods.
1555 total_bits += 2 * fmt_opts->databit_count;
1558 sr_dbg("SPI frame: total bits %lu.", total_bits);
1559 if (total_bits > SPI_MAX_WAVELEN)
1561 inc->max_frame_bits = total_bits;
1567 * Setup half-width slots for the two halves of a DATABIT time. Keep
1568 * the "decoration" (CS control) at full width. Setup a rather long
1569 * last slot for potential inter-frame gaps.
1571 * Preset CS and SCK from their idle levels according to the frame format
1572 * configuration. So that idle times outside of SPI transfers are covered
1573 * with simple logic despite the protocol's flexibility.
1575 static int spi_config_frame(struct context *inc)
1577 struct spi_frame_fmt_opts *fmt_opts;
1578 size_t bit_idx, bit_count;
1582 fmt_opts = &inc->curr_opts.frame_format.spi;
1584 /* Configure DATABIT positions for half width (for clock period). */
1586 bit_count = fmt_opts->databit_count;
1587 while (bit_count--) {
1588 inc->bit_scale[bit_idx + 0].div = 2;
1589 inc->bit_scale[bit_idx + 1].div = 2;
1593 inc->bit_scale[bit_idx].mul = fmt_opts->databit_count;
1596 * Seed the protocol handler's internal state before seeing
1597 * first data values. To properly cover idle periods, and to
1598 * operate correctly in the absence of pseudo comments.
1600 * Use internal helpers for sample data initialization. Then
1601 * grab the resulting pin levels as the idle state.
1603 spi_value_discard_prev_data(inc);
1604 spi_pseudo_data_order(inc, TRUE, TRUE, TRUE);
1605 spi_pseudo_select_control(inc, FALSE);
1606 sample_buffer_preset(inc, inc->samples.curr_levels);
1612 * Process protocol dependent pseudo comments. Can affect future frame
1613 * construction and submission, or can immediately emit "inter frame"
1614 * bit patterns like chip select control.
1616 static int spi_proc_pseudo(struct sr_input *in, char *line)
1618 struct context *inc;
1626 word = sr_text_next_word(line, &line);
1631 if (strcmp(word, SPI_PSEUDO_MOSI_ONLY) == 0) {
1632 sr_spew("SPI pseudo: MOSI only");
1633 spi_pseudo_data_order(inc, TRUE, FALSE, TRUE);
1636 if (g_str_has_prefix(word, SPI_PSEUDO_MOSI_FIXED)) {
1637 word += strlen(SPI_PSEUDO_MOSI_FIXED);
1639 ret = sr_atoul_base(word, &v, &endp, inc->read_text.base);
1644 sr_spew("SPI pseudo: MOSI fixed %lu", v);
1645 spi_pseudo_mosi_fixed(inc, v);
1648 if (strcmp(word, SPI_PSEUDO_MISO_ONLY) == 0) {
1649 sr_spew("SPI pseudo: MISO only");
1650 spi_pseudo_data_order(inc, FALSE, TRUE, FALSE);
1653 if (g_str_has_prefix(word, SPI_PSEUDO_MISO_FIXED)) {
1654 word += strlen(SPI_PSEUDO_MISO_FIXED);
1656 ret = sr_atoul_base(word, &v, &endp, inc->read_text.base);
1661 sr_spew("SPI pseudo: MISO fixed %lu", v);
1662 spi_pseudo_miso_fixed(inc, v);
1665 if (strcmp(word, SPI_PSEUDO_MOSI_MISO) == 0) {
1666 sr_spew("SPI pseudo: MOSI then MISO");
1667 spi_pseudo_data_order(inc, TRUE, TRUE, TRUE);
1670 if (strcmp(word, SPI_PSEUDO_MISO_MOSI) == 0) {
1671 sr_spew("SPI pseudo: MISO then MOSI");
1672 spi_pseudo_data_order(inc, TRUE, TRUE, FALSE);
1675 if (strcmp(word, SPI_PSEUDO_CS_ASSERT) == 0) {
1676 sr_spew("SPI pseudo: CS assert");
1677 spi_pseudo_select_control(inc, TRUE);
1680 if (strcmp(word, SPI_PSEUDO_CS_RELEASE) == 0) {
1681 sr_spew("SPI pseudo: CS release");
1682 /* Release CS. Force IDLE to display the pin change. */
1683 spi_pseudo_select_control(inc, FALSE);
1684 ret = spi_write_frame_patterns(inc, TRUE, FALSE);
1687 ret = send_frame(in);
1692 if (g_str_has_prefix(word, SPI_PSEUDO_CS_NEXT)) {
1693 word += strlen(SPI_PSEUDO_CS_NEXT);
1695 ret = sr_atoul_base(word, &v, &endp, 0);
1700 sr_spew("SPI pseudo: CS auto next %lu", v);
1701 spi_pseudo_auto_select(inc, v);
1704 if (strcmp(word, SPI_PSEUDO_IDLE) == 0) {
1705 sr_spew("SPI pseudo: idle");
1706 ret = spi_write_frame_patterns(inc, TRUE, FALSE);
1709 ret = send_frame(in);
1721 * Create the frame's waveform for the given data value. For bidirectional
1722 * communication multiple routine invocations accumulate data bits, while
1723 * the last invocation completes the frame preparation.
1725 static int spi_proc_value(struct context *inc, uint32_t value)
1727 struct spi_proto_context_t *incs;
1730 gboolean auto_cs_end;
1734 incs = inc->curr_opts.prot_priv;
1737 * Discard previous data when we get here after having completed
1738 * a previous frame. This roundtrip from filling in to clearing
1739 * is required to have the caller emit the waveform that we have
1740 * constructed after receiving data values.
1742 if (spi_value_is_bytes_complete(inc)) {
1743 sr_spew("SPI value: discarding previous data");
1744 spi_value_discard_prev_data(inc);
1748 * Consume the caller provided value. Apply data in the order
1749 * that was configured before.
1752 if (!taken && incs->mosi_first && !incs->has_mosi) {
1753 sr_spew("SPI value: grabbing MOSI value");
1754 incs->mosi_byte = value & 0xff;
1755 incs->has_mosi = TRUE;
1758 if (!taken && !incs->has_miso) {
1759 sr_spew("SPI value: grabbing MISO value");
1760 incs->miso_byte = value & 0xff;
1761 incs->has_miso = TRUE;
1763 if (!taken && !incs->mosi_first && !incs->has_mosi) {
1764 sr_spew("SPI value: grabbing MOSI value");
1765 incs->mosi_byte = value & 0xff;
1766 incs->has_mosi = TRUE;
1771 * Generate the waveform when all data values in a byte time
1772 * were seen (all MOSI and MISO including their being optional
1775 * Optionally automatically release CS after a given number of
1776 * data bytes, when requested by the input stream.
1778 if (!spi_value_is_bytes_complete(inc)) {
1779 sr_spew("SPI value: need more values");
1782 auto_cs_end = spi_auto_select_ends(inc);
1783 sr_spew("SPI value: frame complete, drawing, auto CS %d", auto_cs_end);
1784 ret = spi_write_frame_patterns(inc, FALSE, auto_cs_end);
1790 /* Start/end the logic trace with a few bit times of idle level. */
1791 static int spi_get_idle_capture(struct context *inc,
1792 size_t *bitcount, uint8_t *sample)
1795 /* Describe one byte time of idle level. */
1797 *bitcount = inc->max_frame_bits;
1799 *sample = inc->samples.idle_levels;
1803 /* Arrange for a few samples of idle level between UART frames. */
1804 static int spi_get_idle_interframe(struct context *inc,
1805 size_t *samplecount, uint8_t *sample)
1808 /* Describe four bit times, re-use most recent pin levels. */
1810 *samplecount = inc->curr_opts.samples_per_bit;
1814 *sample = inc->samples.curr_levels;
1818 /* }}} SPI protocol handler */
1819 /* {{{ I2C protocol handler */
1827 #define I2C_PINMASK_SCL (1UL << I2C_PIN_SCL)
1828 #define I2C_PINMASK_SDA (1UL << I2C_PIN_SDA)
1830 /* Arrange for automatic ACK for a given number of data bytes. */
1831 static void i2c_auto_ack_start(struct context *inc, size_t count)
1833 struct i2c_proto_context_t *incs;
1835 incs = inc->curr_opts.prot_priv;
1836 incs->ack_remain = count;
1839 /* Check whether automatic ACK is still applicable. Decrements. */
1840 static gboolean i2c_auto_ack_avail(struct context *inc)
1842 struct i2c_proto_context_t *incs;
1844 incs = inc->curr_opts.prot_priv;
1845 if (!incs->ack_remain)
1848 if (incs->ack_remain--)
1853 /* Occupy the slots where START/STOP would be. Keep current levels. */
1854 static int i2c_write_nothing(struct context *inc)
1859 reps = I2C_BITTIME_QUANTA;
1861 ret = wave_append_buffer(inc);
1870 * Construct a START symbol. Occupy a full bit time in the waveform.
1871 * Can also be used as REPEAT START due to its conservative signalling.
1873 * Definition of START: Falling SDA while SCL is high.
1874 * Repeated START: A START without a preceeding STOP.
1876 static int i2c_write_start(struct context *inc)
1881 * Important! Assumes that either SDA and SCL already are
1882 * high (true when we come here from an idle bus). Or that
1883 * SCL already is low before SDA potentially changes (this
1884 * is true for preceeding START or REPEAT START or DATA BIT
1887 * Implementation detail: This START implementation can be
1888 * used for REPEAT START as well. The signalling sequence is
1889 * conservatively done.
1892 /* Enforce SDA high. */
1893 sample_buffer_raise(inc, I2C_PINMASK_SDA);
1894 ret = wave_append_buffer(inc);
1898 /* Enforce SCL high. */
1899 sample_buffer_raise(inc, I2C_PINMASK_SCL);
1900 ret = wave_append_buffer(inc);
1904 /* Keep high SCL and high SDA for another period. */
1905 ret = wave_append_buffer(inc);
1909 /* Falling SDA while SCL is high. */
1910 sample_buffer_clear(inc, I2C_PINMASK_SDA);
1911 ret = wave_append_buffer(inc);
1915 /* Keep high SCL and low SDA for one more period. */
1916 ret = wave_append_buffer(inc);
1921 * Lower SCL here already. Which kind of prepares DATA BIT
1922 * times (fits a data bit's start condition, does not harm).
1923 * Improves back to back START and (repeated) START as well
1924 * as STOP without preceeding DATA BIT.
1926 sample_buffer_clear(inc, I2C_PINMASK_SCL);
1927 ret = wave_append_buffer(inc);
1935 * Construct a STOP symbol. Occupy a full bit time in the waveform.
1937 * Definition of STOP: Rising SDA while SCL is high.
1939 static int i2c_write_stop(struct context *inc)
1943 /* Enforce SCL low before SDA changes. */
1944 sample_buffer_clear(inc, I2C_PINMASK_SCL);
1945 ret = wave_append_buffer(inc);
1949 /* Enforce SDA low (can change while SCL is low). */
1950 sample_buffer_clear(inc, I2C_PINMASK_SDA);
1951 ret = wave_append_buffer(inc);
1955 /* Rise SCL high while SDA is low. */
1956 sample_buffer_raise(inc, I2C_PINMASK_SCL);
1957 ret = wave_append_buffer(inc);
1961 /* Keep high SCL and low SDA for another period. */
1962 ret = wave_append_buffer(inc);
1967 sample_buffer_raise(inc, I2C_PINMASK_SDA);
1968 ret = wave_append_buffer(inc);
1972 /* Keep high SCL and high SDA for one more periods. */
1973 ret = wave_append_buffer(inc);
1981 * Construct a DATA BIT symbol. Occupy a full bit time in the waveform.
1983 * SDA can change while SCL is low. SDA must be kept while SCL is high.
1985 static int i2c_write_bit(struct context *inc, uint8_t value)
1989 /* Enforce SCL low before SDA changes. */
1990 sample_buffer_clear(inc, I2C_PINMASK_SCL);
1991 ret = wave_append_buffer(inc);
1995 /* Setup SDA pin level while SCL is low. */
1996 sample_buffer_setclr(inc, value, I2C_PINMASK_SDA);
1997 ret = wave_append_buffer(inc);
2001 /* Rising SCL, starting SDA validity. */
2002 sample_buffer_raise(inc, I2C_PINMASK_SCL);
2003 ret = wave_append_buffer(inc);
2007 /* Keep SDA level with high SCL for two more periods. */
2008 ret = wave_append_buffer(inc);
2011 ret = wave_append_buffer(inc);
2015 /* Falling SCL, terminates SDA validity. */
2016 sample_buffer_clear(inc, I2C_PINMASK_SCL);
2017 ret = wave_append_buffer(inc);
2024 /* Create a waveform for the eight data bits and the ACK/NAK slot. */
2025 static int i2c_write_byte(struct context *inc, uint8_t value, uint8_t ack)
2027 size_t bit_mask, bit_value;
2030 /* Keep an empty bit time before the data byte. */
2031 ret = i2c_write_nothing(inc);
2035 /* Send 8 data bits, MSB first. */
2038 bit_value = value & bit_mask;
2040 ret = i2c_write_bit(inc, bit_value);
2045 /* Send ACK, which is low active. NAK is recessive, high. */
2047 ret = i2c_write_bit(inc, bit_value);
2051 /* Keep an empty bit time after the data byte. */
2052 ret = i2c_write_nothing(inc);
2059 /* Send slave address (7bit or 10bit, 1 or 2 bytes). Consumes one ACK. */
2060 static int i2c_send_address(struct sr_input *in, uint16_t addr, gboolean read)
2062 struct context *inc;
2063 struct i2c_frame_fmt_opts *fmt_opts;
2065 uint8_t addr_byte, rw_bit;
2069 fmt_opts = &inc->curr_opts.frame_format.i2c;
2072 rw_bit = read ? 1 : 0;
2073 with_ack = i2c_auto_ack_avail(inc);
2075 if (!fmt_opts->addr_10bit) {
2076 /* 7 bit address, the simple case. */
2077 addr_byte = addr & 0x7f;
2079 addr_byte |= rw_bit;
2080 sr_spew("I2C 7bit address, byte 0x%" PRIx8, addr_byte);
2081 ret = wave_clear_sequence(inc);
2084 ret = i2c_write_byte(inc, addr_byte, with_ack);
2087 ret = send_frame(in);
2092 * 10 bit address, need to write two bytes: First byte
2093 * with prefix 0xf0, upper most 2 address bits, and R/W.
2094 * Second byte with lower 8 address bits.
2096 addr_byte = addr >> 8;
2099 addr_byte |= rw_bit;
2100 sr_spew("I2C 10bit address, byte 0x%" PRIx8, addr_byte);
2101 ret = wave_clear_sequence(inc);
2104 ret = i2c_write_byte(inc, addr_byte, with_ack);
2107 ret = send_frame(in);
2111 addr_byte = addr & 0xff;
2112 sr_spew("I2C 10bit address, byte 0x%" PRIx8, addr_byte);
2113 ret = wave_clear_sequence(inc);
2116 ret = i2c_write_byte(inc, addr_byte, with_ack);
2119 ret = send_frame(in);
2127 /* I2C specific options and frame format check. */
2128 static int i2c_check_opts(struct context *inc)
2130 struct i2c_frame_fmt_opts *fmt_opts;
2131 const char *fmt_text;
2133 size_t opt_count, opt_idx;
2138 fmt_opts = &inc->curr_opts.frame_format.i2c;
2140 /* Apply defaults before reading external specs. */
2141 memset(fmt_opts, 0, sizeof(*fmt_opts));
2142 fmt_opts->addr_10bit = FALSE;
2144 /* Provide a default I2C frame format. */
2145 fmt_text = inc->curr_opts.fmt_text;
2146 if (!fmt_text || !*fmt_text)
2147 fmt_text = I2C_DFLT_FRAMEFMT;
2148 sr_dbg("I2C frame format: %s.", fmt_text);
2150 /* Accept comma separated key=value pairs of specs. */
2151 opts = g_strsplit_set(fmt_text, ", ", 0);
2152 opt_count = g_strv_length(opts);
2153 for (opt_idx = 0; opt_idx < opt_count; opt_idx++) {
2154 opt = opts[opt_idx];
2157 sr_spew("I2C format option: %s.", opt);
2158 if (strcmp(opt, I2C_FORMAT_ADDR_7BIT) == 0) {
2159 sr_spew("I2C address: 7 bit");
2160 fmt_opts->addr_10bit = FALSE;
2163 if (strcmp(opt, I2C_FORMAT_ADDR_10BIT) == 0) {
2164 sr_spew("I2C address: 10 bit");
2165 fmt_opts->addr_10bit = TRUE;
2172 /* Get the total slot count. Leave plenty room for convenience. */
2174 total_bits += I2C_BITTIME_SLOTS;
2175 total_bits *= I2C_BITTIME_QUANTA;
2176 total_bits += I2C_ADD_IDLESLOTS;
2178 sr_dbg("I2C frame: total bits %lu.", total_bits);
2179 if (total_bits > I2C_MAX_WAVELEN)
2181 inc->max_frame_bits = total_bits;
2187 * Don't bother with wide and narrow slots, just assume equal size for
2188 * them all. Edges will occupy exactly one sample, then levels are kept.
2189 * This protocol handler's oversampling should be sufficient for decoders
2190 * to extract the content from generated waveforms.
2192 * Start with high levels on SCL and SDA for an idle bus condition.
2194 static int i2c_config_frame(struct context *inc)
2196 struct i2c_proto_context_t *incs;
2202 incs = inc->curr_opts.prot_priv;
2204 memset(incs, 0, sizeof(*incs));
2205 incs->ack_remain = 0;
2208 * Adjust all time slots since they represent a smaller quanta
2209 * of an I2C bit time.
2211 for (bit_idx = 0; bit_idx < inc->max_frame_bits; bit_idx++) {
2212 inc->bit_scale[bit_idx].div = I2C_BITTIME_QUANTA;
2216 sample |= I2C_PINMASK_SCL;
2217 sample |= I2C_PINMASK_SDA;
2218 sample_buffer_preset(inc, sample);
2224 * Process protocol dependent pseudo comments. Can affect future frame
2225 * construction and submission, or can immediately emit "inter frame"
2226 * bit patterns like START/STOP control. Use wide waveforms for these
2227 * transfer controls, put the special symbol nicely centered. Supports
2228 * users during interactive exploration of generated waveforms.
2230 static int i2c_proc_pseudo(struct sr_input *in, char *line)
2232 struct context *inc;
2241 word = sr_text_next_word(line, &line);
2246 sr_spew("I2C pseudo: word %s", word);
2247 if (strcmp(word, I2C_PSEUDO_START) == 0) {
2248 sr_spew("I2C pseudo: send START");
2249 ret = wave_clear_sequence(inc);
2252 bits = I2C_BITTIME_SLOTS / 2;
2254 ret = i2c_write_nothing(inc);
2258 ret = i2c_write_start(inc);
2261 bits = I2C_BITTIME_SLOTS / 2;
2263 ret = i2c_write_nothing(inc);
2267 ret = send_frame(in);
2272 if (strcmp(word, I2C_PSEUDO_REP_START) == 0) {
2273 sr_spew("I2C pseudo: send REPEAT START");
2274 ret = wave_clear_sequence(inc);
2277 bits = I2C_BITTIME_SLOTS / 2;
2279 ret = i2c_write_nothing(inc);
2283 ret = i2c_write_start(inc);
2286 bits = I2C_BITTIME_SLOTS / 2;
2288 ret = i2c_write_nothing(inc);
2292 ret = send_frame(in);
2297 if (strcmp(word, I2C_PSEUDO_STOP) == 0) {
2298 sr_spew("I2C pseudo: send STOP");
2299 ret = wave_clear_sequence(inc);
2302 bits = I2C_BITTIME_SLOTS / 2;
2304 ret = i2c_write_nothing(inc);
2308 ret = i2c_write_stop(inc);
2311 bits = I2C_BITTIME_SLOTS / 2;
2313 ret = i2c_write_nothing(inc);
2317 ret = send_frame(in);
2322 if (g_str_has_prefix(word, I2C_PSEUDO_ADDR_WRITE)) {
2323 word += strlen(I2C_PSEUDO_ADDR_WRITE);
2325 ret = sr_atoul_base(word, &v, &endp, 0);
2330 sr_spew("I2C pseudo: addr write %lu", v);
2331 ret = i2c_send_address(in, v, FALSE);
2336 if (g_str_has_prefix(word, I2C_PSEUDO_ADDR_READ)) {
2337 word += strlen(I2C_PSEUDO_ADDR_READ);
2339 ret = sr_atoul_base(word, &v, &endp, 0);
2344 sr_spew("I2C pseudo: addr read %lu", v);
2345 ret = i2c_send_address(in, v, TRUE);
2350 if (g_str_has_prefix(word, I2C_PSEUDO_ACK_NEXT)) {
2351 word += strlen(I2C_PSEUDO_ACK_NEXT);
2353 ret = sr_atoul_base(word, &v, &endp, 0);
2358 sr_spew("i2c pseudo: ack next %lu", v);
2359 i2c_auto_ack_start(inc, v);
2362 if (strcmp(word, I2C_PSEUDO_ACK_ONCE) == 0) {
2363 sr_spew("i2c pseudo: ack once");
2364 i2c_auto_ack_start(inc, 1);
2374 * Create the frame's waveform for the given data value. Automatically
2375 * track ACK bits, Fallback to NAK when externally specified ACK counts
2376 * have expired. The caller sends the waveform that we created.
2378 static int i2c_proc_value(struct context *inc, uint32_t value)
2386 with_ack = i2c_auto_ack_avail(inc);
2388 ret = wave_clear_sequence(inc);
2391 ret = i2c_write_byte(inc, value, with_ack);
2398 /* Start/end the logic trace with a few bit times of idle level. */
2399 static int i2c_get_idle_capture(struct context *inc,
2400 size_t *bitcount, uint8_t *sample)
2403 /* Describe a byte's time of idle level. */
2405 *bitcount = I2C_BITTIME_SLOTS;
2407 *sample = inc->samples.idle_levels;
2411 /* Arrange for a few samples of idle level between UART frames. */
2412 static int i2c_get_idle_interframe(struct context *inc,
2413 size_t *samplecount, uint8_t *sample)
2417 * The space around regular bytes already is sufficient. We
2418 * don't need to generate an inter-frame gap, but the code is
2419 * prepared to in case we want to in the future.
2422 *samplecount = inc->curr_opts.samples_per_bit;
2426 *sample = inc->samples.curr_levels;
2430 /* }}} I2C protocol handler */
2431 /* {{{ protocol dispatching */
2434 * The list of supported protocols and their handlers, including
2435 * protocol specific defaults. The first item after the NONE slot
2436 * is the default protocol, and takes effect in the absence of any
2437 * user provided or file content provided spec.
2439 static const struct proto_handler_t protocols[PROTO_TYPE_COUNT] = {
2440 [PROTO_TYPE_UART] = {
2443 UART_DFLT_SAMPLERATE,
2444 UART_DFLT_BITRATE, UART_DFLT_FRAMEFMT,
2448 1, (const char *[]){
2449 [UART_PIN_RXTX] = "rxtx",
2457 uart_get_idle_capture,
2458 uart_get_idle_interframe,
2460 [PROTO_TYPE_SPI] = {
2463 SPI_DFLT_SAMPLERATE,
2464 SPI_DFLT_BITRATE, SPI_DFLT_FRAMEFMT,
2468 4, (const char *[]){
2469 [SPI_PIN_SCK] = "sck",
2470 [SPI_PIN_MISO] = "miso",
2471 [SPI_PIN_MOSI] = "mosi",
2472 [SPI_PIN_CS] = "cs",
2475 sizeof(struct spi_proto_context_t),
2480 spi_get_idle_capture,
2481 spi_get_idle_interframe,
2483 [PROTO_TYPE_I2C] = {
2486 I2C_DFLT_SAMPLERATE,
2487 I2C_DFLT_BITRATE, I2C_DFLT_FRAMEFMT,
2491 2, (const char *[]){
2492 [I2C_PIN_SCL] = "scl",
2493 [I2C_PIN_SDA] = "sda",
2496 sizeof(struct i2c_proto_context_t),
2501 i2c_get_idle_capture,
2502 i2c_get_idle_interframe,
2506 static int lookup_protocol_name(struct context *inc)
2509 const struct proto_handler_t *handler;
2514 * Silence compiler warnings. Protocol handlers are free to use
2515 * several alternative sets of primitives for their operation.
2516 * Not using part of the API is nothing worth warning about.
2518 (void)sample_buffer_assign;
2522 inc->curr_opts.protocol_type = PROTO_TYPE_NONE;
2523 inc->curr_opts.prot_hdl = NULL;
2525 name = inc->curr_opts.proto_name;
2526 if (!name || !*name) {
2527 /* Fallback to first item after NONE slot. */
2528 handler = &protocols[PROTO_TYPE_NONE + 1];
2529 name = handler->name;
2532 for (idx = 0; idx < ARRAY_SIZE(protocols); idx++) {
2533 if (idx == PROTO_TYPE_NONE)
2535 handler = &protocols[idx];
2536 if (!handler->name || !*handler->name)
2538 if (strcmp(name, handler->name) != 0)
2540 inc->curr_opts.protocol_type = idx;
2541 inc->curr_opts.prot_hdl = handler;
2542 if (handler->priv_size) {
2543 priv = g_malloc0(handler->priv_size);
2545 return SR_ERR_MALLOC;
2546 inc->curr_opts.prot_priv = priv;
2554 /* }}} protocol dispatching */
2555 /* {{{ text/binary input file reader */
2558 * Checks for UTF BOM, removes it when found at the start of the buffer.
2560 * @param[in] buf The accumulated input buffer.
2562 static void check_remove_bom(GString *buf)
2564 static const char *bom_text = "\xef\xbb\xbf";
2566 if (buf->len < strlen(bom_text))
2568 if (strncmp(buf->str, bom_text, strlen(bom_text)) != 0)
2570 g_string_erase(buf, 0, strlen(bom_text));
2574 * Checks for presence of a caption, yields the position after its text line.
2576 * @param[in] buf The accumulated input buffer.
2577 * @param[in] caption The text to search for (NUL terminated ASCII literal).
2578 * @param[in] max_pos The maximum length to search for.
2580 * @returns The position after the text line which contains the caption.
2581 * Or #NULL when either the caption or the end-of-line was not found.
2583 static char *have_text_line(GString *buf, const char *caption, size_t max_pos)
2585 size_t cap_len, rem_len;
2586 char *p_read, *p_found;
2588 cap_len = strlen(caption);
2592 /* Search for the occurance of the caption itself. */
2594 /* Caption must be at the start of the buffer. */
2595 if (rem_len < cap_len)
2597 if (strncmp(p_read, caption, cap_len) != 0)
2600 /* Caption can be anywhere up to a max position. */
2601 p_found = g_strstr_len(p_read, rem_len, caption);
2604 /* Pretend that caption had been rather long. */
2605 cap_len += p_found - p_read;
2609 * Advance over the caption. Advance over end-of-line. Supports
2610 * several end-of-line conditions, but rejects unexpected trailer
2611 * after the caption and before the end-of-line. Always wants LF.
2615 while (rem_len && *p_read != '\n' && g_ascii_isspace(*p_read)) {
2619 if (rem_len && *p_read != '\n' && *p_read == '\r') {
2623 if (rem_len && *p_read == '\n') {
2633 * Checks for the presence of the magic string at the start of the file.
2635 * @param[in] buf The accumulated input buffer.
2636 * @param[out] next_pos The text after the magic text line.
2638 * @returns Boolean whether the magic was found.
2640 * This implementation assumes that the magic file type marker never gets
2641 * split across receive chunks.
2643 static gboolean have_magic(GString *buf, char **next_pos)
2650 next_line = have_text_line(buf, MAGIC_FILE_TYPE, 0);
2655 *next_pos = next_line;
2661 * Checks for the presence of the header section at the start of the file.
2663 * @param[in] buf The accumulated input buffer.
2664 * @param[out] next_pos The text after the header section.
2666 * @returns A negative value when the answer is yet unknown (insufficient
2667 * input data). Or boolean 0/1 when the header was found absent/present.
2669 * The caller is supposed to have checked for and removed the magic text
2670 * for the file type. This routine expects to find the header section
2671 * boundaries right at the start of the input buffer.
2673 * This implementation assumes that the header start marker never gets
2674 * split across receive chunks.
2676 static int have_header(GString *buf, char **next_pos)
2678 char *after_start, *after_end;
2683 after_start = have_text_line(buf, TEXT_HEAD_START, 0);
2687 after_end = have_text_line(buf, TEXT_HEAD_END, buf->len);
2692 *next_pos = after_end;
2697 * Implementation detail: Most parse routines merely accept an input
2698 * string or at most convert text to numbers. Actual processing of the
2699 * values or constraints checks are done later when the header section
2700 * ended and all data was seen, regardless of order of appearance.
2703 static int parse_samplerate(struct context *inc, const char *text)
2708 ret = sr_parse_sizestring(text, &rate);
2712 inc->curr_opts.samplerate = rate;
2717 static int parse_bitrate(struct context *inc, const char *text)
2722 ret = sr_parse_sizestring(text, &rate);
2726 inc->curr_opts.bitrate = rate;
2731 static int parse_protocol(struct context *inc, const char *line)
2734 if (!line || !*line)
2737 if (inc->curr_opts.proto_name) {
2738 free(inc->curr_opts.proto_name);
2739 inc->curr_opts.proto_name = NULL;
2741 inc->curr_opts.proto_name = g_strdup(line);
2742 if (!inc->curr_opts.proto_name)
2743 return SR_ERR_MALLOC;
2744 line = inc->curr_opts.proto_name;
2749 static int parse_frameformat(struct context *inc, const char *line)
2752 if (!line || !*line)
2755 if (inc->curr_opts.fmt_text) {
2756 free(inc->curr_opts.fmt_text);
2757 inc->curr_opts.fmt_text = NULL;
2759 inc->curr_opts.fmt_text = g_strdup(line);
2760 if (!inc->curr_opts.fmt_text)
2761 return SR_ERR_MALLOC;
2762 line = inc->curr_opts.fmt_text;
2767 static int parse_textinput(struct context *inc, const char *text)
2771 if (!text || !*text)
2774 is_text = sr_parse_boolstring(text);
2775 inc->curr_opts.textinput = is_text ? INPUT_TEXT : INPUT_BYTES;
2779 static int parse_header_line(struct context *inc, const char *line)
2782 /* Silently ignore comment lines. Also covers start/end markers. */
2783 if (strncmp(line, TEXT_COMM_LEADER, strlen(TEXT_COMM_LEADER)) == 0)
2786 if (strncmp(line, LABEL_SAMPLERATE, strlen(LABEL_SAMPLERATE)) == 0) {
2787 line += strlen(LABEL_SAMPLERATE);
2788 return parse_samplerate(inc, line);
2790 if (strncmp(line, LABEL_BITRATE, strlen(LABEL_BITRATE)) == 0) {
2791 line += strlen(LABEL_BITRATE);
2792 return parse_bitrate(inc, line);
2794 if (strncmp(line, LABEL_PROTOCOL, strlen(LABEL_PROTOCOL)) == 0) {
2795 line += strlen(LABEL_PROTOCOL);
2796 return parse_protocol(inc, line);
2798 if (strncmp(line, LABEL_FRAMEFORMAT, strlen(LABEL_FRAMEFORMAT)) == 0) {
2799 line += strlen(LABEL_FRAMEFORMAT);
2800 return parse_frameformat(inc, line);
2802 if (strncmp(line, LABEL_TEXTINPUT, strlen(LABEL_TEXTINPUT)) == 0) {
2803 line += strlen(LABEL_TEXTINPUT);
2804 return parse_textinput(inc, line);
2807 /* Unsupported directive. */
2808 sr_err("Unsupported header directive: %s.", line);
2813 static int parse_header(struct context *inc, GString *buf, size_t hdr_len)
2816 char *curr, *next, *line;
2821 /* The caller determined where the header ends. Read up to there. */
2824 while (curr && remain) {
2825 /* Get another text line. Skip empty lines. */
2826 line = sr_text_next_line(curr, remain, &next, NULL);
2830 remain -= next - curr;
2836 /* Process the non-empty file header text line. */
2837 sr_dbg("Header line: %s", line);
2838 ret = parse_header_line(inc, line);
2846 /* Process input text reader specific pseudo comment. */
2847 static int process_pseudo_textinput(struct sr_input *in, char *line)
2849 struct context *inc;
2857 word = sr_text_next_word(line, &line);
2862 if (g_str_has_prefix(word, TEXT_INPUT_RADIX)) {
2863 word += strlen(TEXT_INPUT_RADIX);
2865 ret = sr_atoul_base(word, &v, &endp, 10);
2868 inc->read_text.base = v;
2877 /* Process a line of input text. */
2878 static int process_textline(struct sr_input *in, char *line)
2880 struct context *inc;
2881 const struct proto_handler_t *handler;
2882 gboolean is_comm, is_pseudo;
2883 char *p, *word, *endp;
2884 unsigned long value;
2888 handler = inc->curr_opts.prot_hdl;
2891 * Check for comments, including pseudo-comments with protocol
2892 * specific or text reader specific instructions. It's essential
2893 * to check for "# ${PROTO}:" last, because the implementation
2894 * of the check advances the read position, cannot rewind when
2895 * detection fails. But we know that it is a comment and was not
2896 * a pseudo-comment. So any non-matching data just gets discarded.
2897 * Matching data gets processed (when handlers exist).
2899 is_comm = g_str_has_prefix(line, TEXT_COMM_LEADER);
2901 line += strlen(TEXT_COMM_LEADER);
2902 while (isspace(*line))
2904 is_pseudo = g_str_has_prefix(line, TEXT_INPUT_PREFIX);
2906 line += strlen(TEXT_INPUT_PREFIX);
2907 while (isspace(*line))
2909 sr_dbg("pseudo comment, textinput: %s", line);
2910 line = sr_text_trim_spaces(line);
2911 return process_pseudo_textinput(in, line);
2913 is_pseudo = g_str_has_prefix(line, handler->name);
2915 line += strlen(handler->name);
2916 is_pseudo = *line == ':';
2921 while (isspace(*line))
2923 sr_dbg("pseudo comment, protocol: %s", line);
2924 if (!handler->proc_pseudo)
2926 return handler->proc_pseudo(in, line);
2928 sr_spew("comment, skipping: %s", line);
2933 * Non-empty non-comment lines carry protocol values.
2934 * (Empty lines are handled transparently when they get here.)
2935 * Accept comma and semicolon separators for user convenience.
2936 * Convert text according to previously received instructions.
2937 * Pass the values to the protocol handler. Flush waveforms
2938 * when handlers state that their construction has completed.
2940 sr_spew("got values line: %s", line);
2941 for (p = line; *p; p++) {
2942 if (*p == ',' || *p == ';')
2946 word = sr_text_next_word(line, &line);
2951 /* Get another numeric value. */
2953 ret = sr_atoul_base(word, &value, &endp, inc->read_text.base);
2958 sr_spew("got a value, text [%s] -> number [%lu]", word, value);
2959 /* Forward the value to the protocol handler. */
2961 if (handler->proc_value)
2962 ret = handler->proc_value(inc, value);
2965 /* Flush the waveform when handler signals completion. */
2968 ret = send_frame(in);
2971 ret = send_idle_interframe(inc);
2979 /* }}} text/binary input file reader */
2982 * Consistency check of all previously received information. Combines
2983 * the data file's optional header section, as well as user provided
2984 * options that were specified during input module creation. User specs
2985 * take precedence over file content.
2987 static int check_header_user_options(struct context *inc)
2990 const struct proto_handler_t *handler;
2993 enum textinput_t is_text;
2998 /* Prefer user specs over file content. */
2999 rate = inc->user_opts.samplerate;
3001 sr_dbg("Using user samplerate %" PRIu64 ".", rate);
3002 inc->curr_opts.samplerate = rate;
3004 rate = inc->user_opts.bitrate;
3006 sr_dbg("Using user bitrate %" PRIu64 ".", rate);
3007 inc->curr_opts.bitrate = rate;
3009 text = inc->user_opts.proto_name;
3010 if (text && *text) {
3011 sr_dbg("Using user protocol %s.", text);
3012 ret = parse_protocol(inc, text);
3016 text = inc->user_opts.fmt_text;
3017 if (text && *text) {
3018 sr_dbg("Using user frame format %s.", text);
3019 ret = parse_frameformat(inc, text);
3023 is_text = inc->user_opts.textinput;
3025 sr_dbg("Using user textinput %d.", is_text);
3026 inc->curr_opts.textinput = is_text;
3029 /* Lookup the protocol (with fallback). Use protocol's defaults. */
3030 text = inc->curr_opts.proto_name;
3031 ret = lookup_protocol_name(inc);
3032 handler = inc->curr_opts.prot_hdl;
3033 if (ret != SR_OK || !handler) {
3034 sr_err("Unsupported protocol: %s.", text);
3037 text = handler->name;
3038 if (!inc->curr_opts.proto_name && text) {
3039 sr_dbg("Using protocol handler name %s.", text);
3040 ret = parse_protocol(inc, text);
3044 rate = handler->dflt.samplerate;
3045 if (!inc->curr_opts.samplerate && rate) {
3046 sr_dbg("Using protocol handler samplerate %" PRIu64 ".", rate);
3047 inc->curr_opts.samplerate = rate;
3049 rate = handler->dflt.bitrate;
3050 if (!inc->curr_opts.bitrate && rate) {
3051 sr_dbg("Using protocol handler bitrate %" PRIu64 ".", rate);
3052 inc->curr_opts.bitrate = rate;
3054 text = handler->dflt.frame_format;
3055 if (!inc->curr_opts.fmt_text && text && *text) {
3056 sr_dbg("Using protocol handler frame format %s.", text);
3057 ret = parse_frameformat(inc, text);
3061 is_text = handler->dflt.textinput;
3062 if (!inc->curr_opts.textinput && is_text) {
3063 sr_dbg("Using protocol handler text format %d.", is_text);
3064 inc->curr_opts.textinput = is_text;
3067 if (!inc->curr_opts.samplerate) {
3068 sr_err("Need a samplerate.");
3071 if (!inc->curr_opts.bitrate) {
3072 sr_err("Need a protocol bitrate.");
3076 if (inc->curr_opts.samplerate < inc->curr_opts.bitrate) {
3077 sr_err("Bitrate cannot exceed samplerate.");
3080 if (inc->curr_opts.samplerate / inc->curr_opts.bitrate < 3)
3081 sr_warn("Low oversampling, consider higher samplerate.");
3082 if (inc->curr_opts.prot_hdl->check_opts) {
3083 ret = inc->curr_opts.prot_hdl->check_opts(inc);
3085 sr_err("Options failed the protocol's check.");
3093 static int create_channels(struct sr_input *in)
3095 struct context *inc;
3096 struct sr_dev_inst *sdi;
3097 const struct proto_handler_t *handler;
3107 handler = inc->curr_opts.prot_hdl;
3109 for (index = 0; index < handler->chans.count; index++) {
3110 name = handler->chans.names[index];
3111 sr_dbg("Channel %zu name %s.", index, name);
3112 sr_channel_new(sdi, index, SR_CHANNEL_LOGIC, TRUE, name);
3115 inc->feed_logic = feed_queue_logic_alloc(in->sdi,
3116 CHUNK_SIZE, sizeof(uint8_t));
3117 if (!inc->feed_logic) {
3118 sr_err("Cannot create session feed.");
3119 return SR_ERR_MALLOC;
3126 * Keep track of a previously created channel list, in preparation of
3127 * re-reading the input file. Gets called from reset()/cleanup() paths.
3129 static void keep_header_for_reread(const struct sr_input *in)
3131 struct context *inc;
3135 g_slist_free_full(inc->prev.sr_groups, sr_channel_group_free_cb);
3136 inc->prev.sr_groups = in->sdi->channel_groups;
3137 in->sdi->channel_groups = NULL;
3139 g_slist_free_full(inc->prev.sr_channels, sr_channel_free_cb);
3140 inc->prev.sr_channels = in->sdi->channels;
3141 in->sdi->channels = NULL;
3145 * Check whether the input file is being re-read, and refuse operation
3146 * when essential parameters of the acquisition have changed in ways
3147 * that are unexpected to calling applications. Gets called after the
3148 * file header got parsed (again).
3150 * Changing the channel list across re-imports of the same file is not
3151 * supported, by design and for valid reasons, see bug #1215 for details.
3152 * Users are expected to start new sessions when they change these
3153 * essential parameters in the acquisition's setup. When we accept the
3154 * re-read file, then make sure to keep using the previous channel list,
3155 * applications may still reference them.
3157 static gboolean check_header_in_reread(const struct sr_input *in)
3159 struct context *inc;
3166 if (!inc->prev.sr_channels)
3169 if (sr_channel_lists_differ(inc->prev.sr_channels, in->sdi->channels)) {
3170 sr_err("Channel list change not supported for file re-read.");
3174 g_slist_free_full(in->sdi->channel_groups, sr_channel_group_free_cb);
3175 in->sdi->channel_groups = inc->prev.sr_groups;
3176 inc->prev.sr_groups = NULL;
3178 g_slist_free_full(in->sdi->channels, sr_channel_free_cb);
3179 in->sdi->channels = inc->prev.sr_channels;
3180 inc->prev.sr_channels = NULL;
3185 /* Process another chunk of accumulated input data. */
3186 static int process_buffer(struct sr_input *in, gboolean is_eof)
3188 struct context *inc;
3192 const struct proto_handler_t *handler;
3199 handler = inc->curr_opts.prot_hdl;
3202 * Send feed header and samplerate once before any sample data.
3203 * Communicate an idle period before the first generated frame.
3205 if (!inc->started) {
3206 std_session_send_df_header(in->sdi);
3207 gvar = g_variant_new_uint64(inc->curr_opts.samplerate);
3208 ret = sr_session_send_meta(in->sdi, SR_CONF_SAMPLERATE, gvar);
3209 inc->started = TRUE;
3213 ret = send_idle_capture(inc);
3219 * Force proper line termination when EOF is seen and the data
3220 * is in text format. This does not affect binary input, while
3221 * properly terminated text input does not suffer from another
3222 * line feed, because empty lines are considered acceptable.
3223 * Increases robustness for text input from broken generators
3224 * (popular editors which don't terminate the last line).
3226 if (inc->curr_opts.textinput == INPUT_TEXT && is_eof) {
3227 g_string_append_c(buf, '\n');
3231 * For text input: Scan for the completion of another text line.
3232 * Process its values (or pseudo comments). Skip comment lines.
3234 if (inc->curr_opts.textinput == INPUT_TEXT) do {
3235 /* Get another line of text. */
3237 line = sr_text_next_line(buf->str, buf->len, &next, &seen);
3240 /* Process non-empty input lines. */
3241 ret = *line ? process_textline(in, line) : 0;
3244 /* Discard processed input text. */
3245 g_string_erase(buf, 0, seen);
3249 * For binary input: Pass data values (individual bytes) to the
3250 * creation of protocol frames. Send the frame's waveform to
3251 * logic channels in the session feed when the protocol handler
3252 * signals the completion of another waveform (zero return value).
3253 * Non-zero positive values translate to "need more input data".
3254 * Negative values signal fatal errors. Remove processed input
3255 * data from the receive buffer.
3257 if (inc->curr_opts.textinput == INPUT_BYTES) {
3259 while (seen < buf->len) {
3260 sample = buf->str[seen++];
3262 if (handler->proc_value)
3263 ret = handler->proc_value(inc, sample);
3268 ret = send_frame(in);
3271 ret = send_idle_interframe(inc);
3275 g_string_erase(buf, 0, seen);
3278 /* Send idle level, and flush when end of input data is seen. */
3281 sr_warn("Unprocessed input data remains.");
3283 ret = send_idle_capture(inc);
3287 ret = feed_queue_logic_flush(inc->feed_logic);
3295 static int format_match(GHashTable *metadata, unsigned int *confidence)
3297 GString *buf, *tmpbuf;
3300 buf = g_hash_table_lookup(metadata,
3301 GINT_TO_POINTER(SR_INPUT_META_HEADER));
3302 tmpbuf = g_string_new_len(buf->str, buf->len);
3304 check_remove_bom(tmpbuf);
3305 has_magic = have_magic(tmpbuf, NULL);
3306 g_string_free(tmpbuf, TRUE);
3315 static int init(struct sr_input *in, GHashTable *options)
3317 struct context *inc;
3323 in->sdi = g_malloc0(sizeof(*in->sdi));
3324 inc = g_malloc0(sizeof(*inc));
3328 * Store user specified options for later reference.
3330 * TODO How to most appropriately hook up size strings with the
3331 * input module's defaults, and applications and their input
3334 gvar = g_hash_table_lookup(options, "samplerate");
3336 rate = g_variant_get_uint64(gvar);
3338 sr_dbg("User samplerate %" PRIu64 ".", rate);
3339 inc->user_opts.samplerate = rate;
3342 gvar = g_hash_table_lookup(options, "bitrate");
3344 rate = g_variant_get_uint64(gvar);
3346 sr_dbg("User bitrate %" PRIu64 ".", rate);
3347 inc->user_opts.bitrate = rate;
3350 gvar = g_hash_table_lookup(options, "protocol");
3352 copy = g_strdup(g_variant_get_string(gvar, NULL));
3354 return SR_ERR_MALLOC;
3356 sr_dbg("User protocol %s.", copy);
3357 inc->user_opts.proto_name = copy;
3360 gvar = g_hash_table_lookup(options, "frameformat");
3362 copy = g_strdup(g_variant_get_string(gvar, NULL));
3364 return SR_ERR_MALLOC;
3366 sr_dbg("User frame format %s.", copy);
3367 inc->user_opts.fmt_text = copy;
3370 inc->user_opts.textinput = INPUT_UNSPEC;
3371 gvar = g_hash_table_lookup(options, "textinput");
3373 text = g_variant_get_string(gvar, NULL);
3378 sr_dbg("User text input %s.", text);
3379 if (strcmp(text, input_format_texts[INPUT_UNSPEC]) == 0) {
3380 inc->user_opts.textinput = INPUT_UNSPEC;
3381 } else if (strcmp(text, input_format_texts[INPUT_BYTES]) == 0) {
3382 inc->user_opts.textinput = INPUT_BYTES;
3383 } else if (strcmp(text, input_format_texts[INPUT_TEXT]) == 0) {
3384 inc->user_opts.textinput = INPUT_TEXT;
3393 static int receive(struct sr_input *in, GString *buf)
3395 struct context *inc;
3396 char *after_magic, *after_header;
3403 * Accumulate all input chunks, potential deferred processing.
3405 * Remove an optional BOM at the very start of the input stream.
3406 * BEWARE! This may affect binary input, and we cannot tell if
3407 * the input is text or binary at this stage. Though probability
3408 * for this issue is rather low. Workarounds are available (put
3409 * another values before the first data which happens to match
3410 * the BOM pattern, provide text input instead).
3412 g_string_append_len(in->buf, buf->str, buf->len);
3413 if (!inc->scanned_magic)
3414 check_remove_bom(in->buf);
3417 * Must complete reception of the (optional) header first. Both
3418 * end of header and absence of header will: Check options that
3419 * were seen so far, then start processing the data part.
3421 if (!inc->got_header) {
3422 /* Check for magic file type marker. */
3423 if (!inc->scanned_magic) {
3424 inc->has_magic = have_magic(in->buf, &after_magic);
3425 inc->scanned_magic = TRUE;
3426 if (inc->has_magic) {
3427 consumed = after_magic - in->buf->str;
3428 sr_dbg("File format magic found (%zu).", consumed);
3429 g_string_erase(in->buf, 0, consumed);
3433 /* Complete header reception and processing. */
3434 if (inc->has_magic) {
3435 ret = have_header(in->buf, &after_header);
3438 inc->has_header = ret;
3439 if (inc->has_header) {
3440 consumed = after_header - in->buf->str;
3441 sr_dbg("File header found (%zu), processing.", consumed);
3442 ret = parse_header(inc, in->buf, consumed);
3445 g_string_erase(in->buf, 0, consumed);
3448 inc->got_header = TRUE;
3451 * Postprocess the combination of all options. Create
3452 * logic channels, prepare resources for data processing.
3454 ret = check_header_user_options(inc);
3457 ret = create_channels(in);
3460 if (!check_header_in_reread(in))
3462 ret = alloc_frame_storage(inc);
3465 ret = assign_bit_widths(inc);
3469 /* Notify the frontend that sdi is ready. */
3470 in->sdi_ready = TRUE;
3475 * Process the input file's data section after the header section
3476 * was received and processed.
3478 ret = process_buffer(in, FALSE);
3483 static int end(struct sr_input *in)
3485 struct context *inc;
3490 /* Must complete processing of previously received chunks. */
3491 if (in->sdi_ready) {
3492 ret = process_buffer(in, TRUE);
3497 /* Must send DF_END when DF_HEADER was sent before. */
3499 ret = std_session_send_df_end(in->sdi);
3507 static void cleanup(struct sr_input *in)
3509 struct context *inc;
3513 keep_header_for_reread(in);
3515 g_free(inc->curr_opts.proto_name);
3516 inc->curr_opts.proto_name = NULL;
3517 g_free(inc->curr_opts.fmt_text);
3518 inc->curr_opts.fmt_text = NULL;
3519 g_free(inc->curr_opts.prot_priv);
3520 inc->curr_opts.prot_priv = NULL;
3521 feed_queue_logic_free(inc->feed_logic);
3522 inc->feed_logic = NULL;
3523 g_free(inc->sample_edges);
3524 inc->sample_edges = NULL;
3525 g_free(inc->sample_widths);
3526 inc->sample_widths = NULL;
3527 g_free(inc->sample_levels);
3528 inc->sample_levels = NULL;
3529 g_free(inc->bit_scale);
3530 inc->bit_scale = NULL;
3533 static int reset(struct sr_input *in)
3535 struct context *inc;
3536 struct user_opts_t save_user_opts;
3537 struct proto_prev save_chans;
3541 /* Release previously allocated resources. */
3543 g_string_truncate(in->buf, 0);
3545 /* Restore part of the context, init() won't run again. */
3546 save_user_opts = inc->user_opts;
3547 save_chans = inc->prev;
3548 memset(inc, 0, sizeof(*inc));
3549 inc->user_opts = save_user_opts;
3550 inc->prev = save_chans;
3555 enum proto_option_t {
3564 static struct sr_option options[] = {
3565 [OPT_SAMPLERATE] = {
3566 "samplerate", "Logic data samplerate",
3567 "Samplerate of generated logic traces",
3571 "bitrate", "Protocol bitrate",
3572 "Bitrate used in protocol's communication",
3576 "protocol", "Protocol type",
3577 "The type of protocol to generate waveforms for",
3580 [OPT_FRAME_FORMAT] = {
3581 "frameformat", "Protocol frame format",
3582 "Textual description of the protocol's frame format",
3586 "textinput", "Input data is in text format",
3587 "Input is not data bytes, but text formatted values",
3590 [OPT_MAX] = ALL_ZERO,
3593 static const struct sr_option *get_options(void)
3596 enum proto_type_t p_idx;
3597 enum textinput_t t_idx;
3603 options[OPT_SAMPLERATE].def = g_variant_ref_sink(g_variant_new_uint64(0));
3604 options[OPT_BITRATE].def = g_variant_ref_sink(g_variant_new_uint64(0));
3605 options[OPT_PROTOCOL].def = g_variant_ref_sink(g_variant_new_string(""));
3607 for (p_idx = 0; p_idx < ARRAY_SIZE(protocols); p_idx++) {
3608 s = protocols[p_idx].name;
3611 l = g_slist_append(l, g_variant_ref_sink(g_variant_new_string(s)));
3613 options[OPT_PROTOCOL].values = l;
3614 options[OPT_FRAME_FORMAT].def = g_variant_ref_sink(g_variant_new_string(""));
3616 for (t_idx = INPUT_UNSPEC; t_idx <= INPUT_TEXT; t_idx++) {
3617 s = input_format_texts[t_idx];
3618 l = g_slist_append(l, g_variant_ref_sink(g_variant_new_string(s)));
3620 options[OPT_TEXTINPUT].values = l;
3621 options[OPT_TEXTINPUT].def = g_variant_ref_sink(g_variant_new_string(
3622 input_format_texts[INPUT_UNSPEC]));
3626 SR_PRIV struct sr_input_module input_protocoldata = {
3627 .id = "protocoldata",
3628 .name = "Protocol data",
3629 .desc = "Generate logic traces from protocol's data values",
3630 .exts = (const char *[]){ "sr-protocol", "protocol", "bin", NULL, },
3631 .metadata = { SR_INPUT_META_HEADER | SR_INPUT_META_REQUIRED },
3632 .options = get_options,
3633 .format_match = format_match,