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;
716 ret = feed_queue_logic_submit_one(inc->feed_logic, &data, count);
723 /* Optionally send idle level between protocol frames. */
724 static int send_idle_interframe(struct context *inc)
726 const struct proto_handler_t *handler;
731 handler = inc->curr_opts.prot_hdl;
732 if (!handler->get_idle_interframe)
735 ret = handler->get_idle_interframe(inc, &count, &data);
738 ret = feed_queue_logic_submit_one(inc->feed_logic, &data, count);
745 /* Forward the previously accumulated samples of the waveform. */
746 static int send_frame(struct sr_input *in)
755 for (index = 0; index < inc->top_frame_bits; index++) {
756 data = inc->sample_levels[index];
757 count = inc->sample_widths[index];
758 ret = feed_queue_logic_submit_one(inc->feed_logic,
767 /* }}} frame bits manipulation */
768 /* {{{ UART protocol handler */
774 #define UART_PINMASK_RXTX (1UL << UART_PIN_RXTX)
776 /* UART specific options and frame format check. */
777 static int uart_check_opts(struct context *inc)
779 struct uart_frame_fmt_opts *fmt_opts;
780 const char *fmt_text;
782 size_t opt_count, opt_idx;
791 fmt_opts = &inc->curr_opts.frame_format.uart;
793 /* Apply defaults before reading external spec. */
794 memset(fmt_opts, 0, sizeof(*fmt_opts));
795 fmt_opts->databit_count = 8;
796 fmt_opts->parity_type = UART_PARITY_NONE;
797 fmt_opts->stopbit_count = 1;
798 fmt_opts->half_stopbit = FALSE;
799 fmt_opts->inverted = FALSE;
801 /* Provide a default UART frame format. */
802 fmt_text = inc->curr_opts.fmt_text;
803 if (!fmt_text || !*fmt_text)
804 fmt_text = UART_DFLT_FRAMEFMT;
805 sr_dbg("UART frame format: %s.", fmt_text);
807 /* Parse the comma separated list of user provided options. */
808 opts = g_strsplit_set(fmt_text, ", ", 0);
809 opt_count = g_strv_length(opts);
810 for (opt_idx = 0; opt_idx < opt_count; opt_idx++) {
814 sr_spew("UART format option: %s", opt);
816 * Check for specific keywords. Before falling back to
817 * attempting the "8n1" et al interpretation.
819 if (strcmp(opt, UART_FORMAT_INVERT) == 0) {
820 fmt_opts->inverted = TRUE;
823 /* Parse an "8n1", "8e2", "7o1", or similar input spec. */
824 /* Get the data bits count. */
826 ret = sr_atoul_base(opt, &v, &endp, 10);
827 if (ret != SR_OK || !endp)
830 if (v < UART_MIN_DATABITS || v > UART_MAX_DATABITS)
832 fmt_opts->databit_count = v;
833 /* Get the parity type. */
834 par_text = tolower((int)*opt++);
837 fmt_opts->parity_type = UART_PARITY_NONE;
840 fmt_opts->parity_type = UART_PARITY_ODD;
843 fmt_opts->parity_type = UART_PARITY_EVEN;
848 /* Get the stop bits count. Supports half bits too. */
850 ret = sr_atoul_base(opt, &v, &endp, 10);
851 if (ret != SR_OK || !endp)
854 if (v > UART_MAX_STOPBITS)
856 fmt_opts->stopbit_count = v;
857 if (g_ascii_strcasecmp(opt, ".5") == 0) {
859 fmt_opts->half_stopbit = TRUE;
861 /* Incomplete consumption of input text is fatal. */
863 sr_err("Unprocessed frame format remainder: %s.", opt);
871 * Calculate the total number of bit times in the UART frame.
872 * Add a few more bit times to the reserved space. They usually
873 * are not occupied during data transmission, but are useful to
874 * have for special symbols (BREAK, IDLE).
876 total_bits = 1; /* START bit, unconditional. */
877 total_bits += fmt_opts->databit_count;
878 total_bits += (fmt_opts->parity_type != UART_PARITY_NONE) ? 1 : 0;
879 total_bits += fmt_opts->stopbit_count;
880 total_bits += fmt_opts->half_stopbit ? 1 : 0;
881 total_bits += UART_ADD_IDLEBITS;
882 sr_dbg("UART frame: total bits %lu.", total_bits);
883 if (total_bits > UART_MAX_WAVELEN)
885 inc->max_frame_bits = total_bits;
891 * Configure the frame's bit widths when not identical across the
892 * complete frame. Think half STOP bits.
893 * Preset the sample data for an idle bus.
895 static int uart_config_frame(struct context *inc)
897 struct uart_frame_fmt_opts *fmt_opts;
903 fmt_opts = &inc->curr_opts.frame_format.uart;
906 * Position after the START bit. Advance over DATA, PARITY and
907 * (full) STOP bits. Then set the trailing STOP bit to half if
908 * needed. Make the trailing IDLE period after a UART frame
909 * wider than regular bit times. Add an even wider IDLE period
910 * which is used for special symbols.
913 bit_idx += fmt_opts->databit_count;
914 bit_idx += (fmt_opts->parity_type == UART_PARITY_NONE) ? 0 : 1;
915 bit_idx += fmt_opts->stopbit_count;
916 if (fmt_opts->half_stopbit) {
917 sr_dbg("Setting bit index %zu to half width.", bit_idx);
918 inc->bit_scale[bit_idx].div = 2;
921 inc->bit_scale[bit_idx++].mul = 2;
922 inc->bit_scale[bit_idx++].mul = 4;
924 /* Start from idle signal levels (high when not inverted). */
926 if (!fmt_opts->inverted)
927 sample |= UART_PINMASK_RXTX;
928 sample_buffer_preset(inc, sample);
933 /* Create samples for a special UART frame (IDLE, BREAK). */
934 static int uart_write_special(struct context *inc, uint8_t level)
936 struct uart_frame_fmt_opts *fmt_opts;
942 fmt_opts = &inc->curr_opts.frame_format.uart;
944 ret = wave_clear_sequence(inc);
949 * Set the same level for all bit slots, covering all of
950 * START and DATA (and PARITY) and STOP. This allows the
951 * simulation of BREAK and IDLE phases.
953 if (fmt_opts->inverted)
955 sample_buffer_setclr(inc, level, UART_PINMASK_RXTX);
956 bits = 1; /* START */
957 bits += fmt_opts->databit_count;
958 bits += (fmt_opts->parity_type != UART_PARITY_NONE) ? 1 : 0;
959 bits += fmt_opts->stopbit_count;
960 bits += fmt_opts->half_stopbit ? 1 : 0;
962 ret = wave_append_buffer(inc);
968 * Force a few more idle bit times. This does not affect a
969 * caller requested IDLE symbol. But helps separate (i.e.
970 * robustly detect) several caller requested BREAK symbols.
971 * Also separates those specials from subsequent data bytes.
973 sample_buffer_toidle(inc);
974 bits = UART_ADD_IDLEBITS;
976 ret = wave_append_buffer(inc);
984 /* Process UART protocol specific pseudo comments. */
985 static int uart_proc_pseudo(struct sr_input *in, char *line)
994 word = sr_text_next_word(line, &line);
999 if (strcmp(word, UART_PSEUDO_BREAK) == 0) {
1000 ret = uart_write_special(inc, 0);
1003 ret = send_frame(in);
1008 if (strcmp(word, UART_PSEUDO_IDLE) == 0) {
1009 ret = uart_write_special(inc, 1);
1012 ret = send_frame(in);
1024 * Create the UART frame's waveform for the given data value.
1026 * In theory the protocol handler could setup START and STOP once during
1027 * initialization. But the overhead compares to DATA and PARITY is small.
1028 * And unconditional START/STOP would break the creation of BREAK and
1029 * IDLE frames, or complicate their construction and recovery afterwards.
1030 * A future implementation might as well support UART traffic on multiple
1031 * traces, including interleaved bidirectional communication. So let's
1032 * keep the implementation simple. Execution time is not a priority.
1034 static int uart_proc_value(struct context *inc, uint32_t value)
1036 struct uart_frame_fmt_opts *fmt_opts;
1039 int par_bit, data_bit;
1043 fmt_opts = &inc->curr_opts.frame_format.uart;
1045 ret = wave_clear_sequence(inc);
1049 /* START bit, unconditional, always 0. */
1050 sample_buffer_clear(inc, UART_PINMASK_RXTX);
1051 if (fmt_opts->inverted)
1052 sample_buffer_toggle(inc, UART_PINMASK_RXTX);
1053 ret = wave_append_buffer(inc);
1055 /* DATA bits. Track parity here (unconditionally). */
1057 bits = fmt_opts->databit_count;
1059 data_bit = value & 0x01;
1061 par_bit ^= data_bit;
1062 if (fmt_opts->inverted)
1063 data_bit = !data_bit;
1064 sample_buffer_setclr(inc, data_bit, UART_PINMASK_RXTX);
1065 ret = wave_append_buffer(inc);
1070 /* PARITY bit. Emission is optional. */
1071 switch (fmt_opts->parity_type) {
1072 case UART_PARITY_ODD:
1073 data_bit = par_bit ? 0 : 1;
1076 case UART_PARITY_EVEN:
1077 data_bit = par_bit ? 1 : 0;
1086 if (fmt_opts->inverted)
1087 data_bit = !data_bit;
1088 sample_buffer_setclr(inc, data_bit, UART_PINMASK_RXTX);
1089 ret = wave_append_buffer(inc);
1094 /* STOP bits. Optional. */
1095 sample_buffer_raise(inc, UART_PINMASK_RXTX);
1096 if (fmt_opts->inverted)
1097 sample_buffer_toggle(inc, UART_PINMASK_RXTX);
1098 bits = fmt_opts->stopbit_count;
1099 bits += fmt_opts->half_stopbit ? 1 : 0;
1101 ret = wave_append_buffer(inc);
1107 * Force some idle time after the UART frame.
1108 * A little shorter than for special symbols.
1110 sample_buffer_toidle(inc);
1111 bits = UART_ADD_IDLEBITS - 1;
1113 ret = wave_append_buffer(inc);
1121 /* Start/end the logic trace with a few bit times of idle level. */
1122 static int uart_get_idle_capture(struct context *inc,
1123 size_t *bitcount, uint8_t *sample)
1126 /* Describe a UART frame's length of idle level. */
1128 *bitcount = inc->max_frame_bits;
1130 *sample = inc->samples.idle_levels;
1134 /* Arrange for a few samples of idle level between UART frames. */
1135 static int uart_get_idle_interframe(struct context *inc,
1136 size_t *samplecount, uint8_t *sample)
1142 * Regular waveform creation for UART frames already includes
1143 * padding between UART frames. That is why we don't need to
1144 * add extra inter-frame samples. Yet prepare the implementation
1145 * for when we need or want to add a few more idle samples.
1148 *samplecount = inc->curr_opts.samples_per_bit;
1152 *sample = inc->samples.idle_levels;
1156 /* }}} UART protocol handler */
1157 /* {{{ SPI protocol handler */
1167 #define SPI_PINMASK_SCK (1UL << SPI_PIN_SCK)
1168 #define SPI_PINMASK_MISO (1UL << SPI_PIN_MISO)
1169 #define SPI_PINMASK_MOSI (1UL << SPI_PIN_MOSI)
1170 #define SPI_PINMASK_CS (1UL << SPI_PIN_CS)
1172 /* "Forget" data which was seen before. */
1173 static void spi_value_discard_prev_data(struct context *inc)
1175 struct spi_proto_context_t *incs;
1177 incs = inc->curr_opts.prot_priv;
1178 incs->has_mosi = !incs->needs_mosi;
1179 incs->has_miso = !incs->needs_miso;
1180 incs->mosi_byte = 0;
1181 incs->miso_byte = 0;
1184 /* Check whether all required values for the byte time were seen. */
1185 static gboolean spi_value_is_bytes_complete(struct context *inc)
1187 struct spi_proto_context_t *incs;
1189 incs = inc->curr_opts.prot_priv;
1191 return incs->has_mosi && incs->has_miso;
1194 /* Arrange for data reception before waveform emission. */
1195 static void spi_pseudo_data_order(struct context *inc,
1196 gboolean needs_mosi, gboolean needs_miso, gboolean mosi_first)
1198 struct spi_proto_context_t *incs;
1200 incs = inc->curr_opts.prot_priv;
1202 incs->needs_mosi = needs_mosi;
1203 incs->needs_miso = needs_miso;
1204 incs->mosi_first = mosi_first;
1206 incs->mosi_is_fixed = FALSE;
1208 incs->miso_is_fixed = FALSE;
1209 spi_value_discard_prev_data(inc);
1212 static void spi_pseudo_mosi_fixed(struct context *inc, uint8_t v)
1214 struct spi_proto_context_t *incs;
1216 incs = inc->curr_opts.prot_priv;
1218 incs->mosi_fixed_value = v;
1219 incs->mosi_is_fixed = TRUE;
1222 static void spi_pseudo_miso_fixed(struct context *inc, uint8_t v)
1224 struct spi_proto_context_t *incs;
1226 incs = inc->curr_opts.prot_priv;
1228 incs->miso_fixed_value = v;
1229 incs->miso_is_fixed = TRUE;
1232 /* Explicit CS control. Arrange for next CS level, track state to keep it. */
1233 static void spi_pseudo_select_control(struct context *inc, gboolean cs_active)
1235 struct spi_frame_fmt_opts *fmt_opts;
1236 struct spi_proto_context_t *incs;
1237 uint8_t cs_level, sck_level;
1239 fmt_opts = &inc->curr_opts.frame_format.spi;
1240 incs = inc->curr_opts.prot_priv;
1242 /* Track current "CS active" state. */
1243 incs->cs_active = cs_active;
1244 incs->auto_cs_remain = 0;
1246 /* Derive current "CS pin level". Update sample data buffer. */
1247 cs_level = 1 - fmt_opts->cs_polarity;
1248 if (incs->cs_active)
1249 cs_level = fmt_opts->cs_polarity;
1250 sample_buffer_setclr(inc, cs_level, SPI_PINMASK_CS);
1252 /* Derive the idle "SCK level" from the SPI mode's CPOL. */
1253 sck_level = fmt_opts->spi_mode_cpol ? 1 : 0;
1254 sample_buffer_setclr(inc, sck_level, SPI_PINMASK_SCK);
1257 /* Arrange for automatic CS release after transfer length. Starts the phase. */
1258 static void spi_pseudo_auto_select(struct context *inc, size_t length)
1260 struct spi_frame_fmt_opts *fmt_opts;
1261 struct spi_proto_context_t *incs;
1264 fmt_opts = &inc->curr_opts.frame_format.spi;
1265 incs = inc->curr_opts.prot_priv;
1267 /* Track current "CS active" state. */
1268 incs->cs_active = TRUE;
1269 incs->auto_cs_remain = length;
1271 /* Derive current "CS pin level". Update sample data buffer. */
1272 cs_level = 1 - fmt_opts->cs_polarity;
1273 if (incs->cs_active)
1274 cs_level = fmt_opts->cs_polarity;
1275 sample_buffer_setclr(inc, cs_level, SPI_PINMASK_CS);
1278 /* Check for automatic CS release. Decrements, yields result. No action here. */
1279 static gboolean spi_auto_select_ends(struct context *inc)
1281 struct spi_proto_context_t *incs;
1283 incs = inc->curr_opts.prot_priv;
1284 if (!incs->auto_cs_remain)
1287 incs->auto_cs_remain--;
1288 if (incs->auto_cs_remain)
1292 * DON'T release CS yet. The last data is yet to get sent.
1293 * Keep the current "CS pin level", but tell the caller that
1294 * CS will be released after transmission of that last data.
1299 /* Update for automatic CS release after last data was sent. */
1300 static void spi_auto_select_update(struct context *inc)
1302 struct spi_frame_fmt_opts *fmt_opts;
1303 struct spi_proto_context_t *incs;
1306 fmt_opts = &inc->curr_opts.frame_format.spi;
1307 incs = inc->curr_opts.prot_priv;
1309 /* Track current "CS active" state. */
1310 incs->cs_active = FALSE;
1311 incs->auto_cs_remain = 0;
1313 /* Derive current "CS pin level". Map to bits pattern. */
1314 cs_level = 1 - fmt_opts->cs_polarity;
1315 sample_buffer_setclr(inc, cs_level, SPI_PINMASK_CS);
1319 * Create the waveforms for one SPI byte. Also cover idle periods:
1320 * Dummy/padding bytes within a frame with clock. Idle lines outside
1321 * of frames without clock edges. Optional automatic CS release with
1322 * resulting inter-frame gap.
1324 static int spi_write_frame_patterns(struct context *inc,
1325 gboolean idle, gboolean cs_release)
1327 struct spi_proto_context_t *incs;
1328 struct spi_frame_fmt_opts *fmt_opts;
1330 uint8_t mosi_bit, miso_bit;
1335 incs = inc->curr_opts.prot_priv;
1336 fmt_opts = &inc->curr_opts.frame_format.spi;
1338 /* Apply fixed values before drawing the waveform. */
1339 if (incs->mosi_is_fixed)
1340 incs->mosi_byte = incs->mosi_fixed_value;
1341 if (incs->miso_is_fixed)
1342 incs->miso_byte = incs->miso_fixed_value;
1344 ret = wave_clear_sequence(inc);
1348 /* Provide two samples with idle SCK and current CS. */
1349 ret = wave_append_buffer(inc);
1352 ret = wave_append_buffer(inc);
1357 * Provide two samples per DATABIT time slot. Keep CS as is.
1358 * Toggle SCK according to CPHA specs. Shift out MOSI and MISO
1359 * in the configured order.
1361 * Force dummy MOSI/MISO bits for idle bytes within a frame.
1362 * Skip SCK toggling for idle "frames" outside of active CS.
1364 bits = fmt_opts->databit_count;
1367 * First half-period. Provide next DATABIT values.
1368 * Toggle SCK here when CPHA is set.
1370 if (fmt_opts->msb_first) {
1371 mosi_bit = incs->mosi_byte & 0x80;
1372 miso_bit = incs->miso_byte & 0x80;
1373 incs->mosi_byte <<= 1;
1374 incs->miso_byte <<= 1;
1376 mosi_bit = incs->mosi_byte & 0x01;
1377 miso_bit = incs->miso_byte & 0x01;
1378 incs->mosi_byte >>= 1;
1379 incs->miso_byte >>= 1;
1381 if (incs->cs_active && !idle) {
1382 sample_buffer_setclr(inc, mosi_bit, SPI_PINMASK_MOSI);
1383 sample_buffer_setclr(inc, miso_bit, SPI_PINMASK_MISO);
1385 if (fmt_opts->spi_mode_cpha && incs->cs_active)
1386 sample_buffer_toggle(inc, SPI_PINMASK_SCK);
1387 ret = wave_append_buffer(inc);
1390 /* Second half-period. Keep DATABIT, toggle SCK. */
1391 if (incs->cs_active)
1392 sample_buffer_toggle(inc, SPI_PINMASK_SCK);
1393 ret = wave_append_buffer(inc);
1396 /* Toggle SCK again unless done above due to CPHA. */
1397 if (!fmt_opts->spi_mode_cpha && incs->cs_active)
1398 sample_buffer_toggle(inc, SPI_PINMASK_SCK);
1402 * Hold the waveform for another sample period. Happens to
1403 * also communicate the most recent SCK pin level.
1405 * Optionally auto-release the CS signal after sending the
1406 * last data byte. Update the CS trace's level. Add another
1407 * (long) bit slot to present an inter-frame gap.
1409 ret = wave_append_buffer(inc);
1413 spi_auto_select_update(inc);
1414 ret = wave_append_buffer(inc);
1418 ret = wave_append_buffer(inc);
1426 /* SPI specific options and frame format check. */
1427 static int spi_check_opts(struct context *inc)
1429 struct spi_frame_fmt_opts *fmt_opts;
1430 const char *fmt_text;
1432 size_t opt_count, opt_idx;
1440 fmt_opts = &inc->curr_opts.frame_format.spi;
1442 /* Setup defaults before reading external specs. */
1443 fmt_opts->cs_polarity = 0;
1444 fmt_opts->databit_count = SPI_MIN_DATABITS;
1445 fmt_opts->msb_first = TRUE;
1446 fmt_opts->spi_mode_cpol = FALSE;
1447 fmt_opts->spi_mode_cpha = FALSE;
1449 /* Provide a default SPI frame format. */
1450 fmt_text = inc->curr_opts.fmt_text;
1451 if (!fmt_text || !*fmt_text)
1452 fmt_text = SPI_DFLT_FRAMEFMT;
1453 sr_dbg("SPI frame format: %s.", fmt_text);
1455 /* Accept comma separated key=value pairs of specs. */
1456 opts = g_strsplit_set(fmt_text, ", ", 0);
1457 opt_count = g_strv_length(opts);
1458 for (opt_idx = 0; opt_idx < opt_count; opt_idx++) {
1459 opt = opts[opt_idx];
1462 sr_spew("SPI format option: %s.", opt);
1463 if (strcmp(opt, SPI_FORMAT_CS_LOW) == 0) {
1464 sr_spew("SPI chip select: low.");
1465 fmt_opts->cs_polarity = 0;
1468 if (strcmp(opt, SPI_FORMAT_CS_HIGH) == 0) {
1469 sr_spew("SPI chip select: high.");
1470 fmt_opts->cs_polarity = 1;
1473 if (g_str_has_prefix(opt, SPI_FORMAT_DATA_BITS)) {
1474 opt += strlen(SPI_FORMAT_DATA_BITS);
1476 ret = sr_atoul_base(opt, &v, &endp, 10);
1481 sr_spew("SPI word size: %lu.", v);
1482 if (v < SPI_MIN_DATABITS || v > SPI_MAX_DATABITS)
1484 fmt_opts->databit_count = v;
1487 if (g_str_has_prefix(opt, SPI_FORMAT_SPI_MODE)) {
1488 opt += strlen(SPI_FORMAT_SPI_MODE);
1490 ret = sr_atoul_base(opt, &v, &endp, 10);
1495 sr_spew("SPI mode: %lu.", v);
1498 fmt_opts->spi_mode_cpol = v & (1UL << 1);
1499 fmt_opts->spi_mode_cpha = v & (1UL << 0);
1502 if (g_str_has_prefix(opt, SPI_FORMAT_MODE_CPOL)) {
1503 opt += strlen(SPI_FORMAT_MODE_CPOL);
1505 ret = sr_atoul_base(opt, &v, &endp, 10);
1510 sr_spew("SPI cpol: %lu.", v);
1513 fmt_opts->spi_mode_cpol = !!v;
1516 if (g_str_has_prefix(opt, SPI_FORMAT_MODE_CPHA)) {
1517 opt += strlen(SPI_FORMAT_MODE_CPHA);
1519 ret = sr_atoul_base(opt, &v, &endp, 10);
1524 sr_spew("SPI cpha: %lu.", v);
1527 fmt_opts->spi_mode_cpha = !!v;
1530 if (strcmp(opt, SPI_FORMAT_MSB_FIRST) == 0) {
1531 sr_spew("SPI endianess: MSB first.");
1532 fmt_opts->msb_first = 1;
1535 if (strcmp(opt, SPI_FORMAT_LSB_FIRST) == 0) {
1536 sr_spew("SPI endianess: LSB first.");
1537 fmt_opts->msb_first = 0;
1545 * Get the total bit count. Add slack for CS control, and to
1546 * visually separate bytes in frames. Multiply data bit count
1547 * for the creation of two clock half-periods.
1550 total_bits += 2 * fmt_opts->databit_count;
1553 sr_dbg("SPI frame: total bits %lu.", total_bits);
1554 if (total_bits > SPI_MAX_WAVELEN)
1556 inc->max_frame_bits = total_bits;
1562 * Setup half-width slots for the two halves of a DATABIT time. Keep
1563 * the "decoration" (CS control) at full width. Setup a rather long
1564 * last slot for potential inter-frame gaps.
1566 * Preset CS and SCK from their idle levels according to the frame format
1567 * configuration. So that idle times outside of SPI transfers are covered
1568 * with simple logic despite the protocol's flexibility.
1570 static int spi_config_frame(struct context *inc)
1572 struct spi_frame_fmt_opts *fmt_opts;
1573 size_t bit_idx, bit_count;
1577 fmt_opts = &inc->curr_opts.frame_format.spi;
1579 /* Configure DATABIT positions for half width (for clock period). */
1581 bit_count = fmt_opts->databit_count;
1582 while (bit_count--) {
1583 inc->bit_scale[bit_idx + 0].div = 2;
1584 inc->bit_scale[bit_idx + 1].div = 2;
1588 inc->bit_scale[bit_idx].mul = fmt_opts->databit_count;
1591 * Seed the protocol handler's internal state before seeing
1592 * first data values. To properly cover idle periods, and to
1593 * operate correctly in the absence of pseudo comments.
1595 * Use internal helpers for sample data initialization. Then
1596 * grab the resulting pin levels as the idle state.
1598 spi_value_discard_prev_data(inc);
1599 spi_pseudo_data_order(inc, TRUE, TRUE, TRUE);
1600 spi_pseudo_select_control(inc, FALSE);
1601 sample_buffer_preset(inc, inc->samples.curr_levels);
1607 * Process protocol dependent pseudo comments. Can affect future frame
1608 * construction and submission, or can immediately emit "inter frame"
1609 * bit patterns like chip select control.
1611 static int spi_proc_pseudo(struct sr_input *in, char *line)
1613 struct context *inc;
1621 word = sr_text_next_word(line, &line);
1626 if (strcmp(word, SPI_PSEUDO_MOSI_ONLY) == 0) {
1627 sr_spew("SPI pseudo: MOSI only");
1628 spi_pseudo_data_order(inc, TRUE, FALSE, TRUE);
1631 if (g_str_has_prefix(word, SPI_PSEUDO_MOSI_FIXED)) {
1632 word += strlen(SPI_PSEUDO_MOSI_FIXED);
1634 ret = sr_atoul_base(word, &v, &endp, inc->read_text.base);
1639 sr_spew("SPI pseudo: MOSI fixed %lu", v);
1640 spi_pseudo_mosi_fixed(inc, v);
1643 if (strcmp(word, SPI_PSEUDO_MISO_ONLY) == 0) {
1644 sr_spew("SPI pseudo: MISO only");
1645 spi_pseudo_data_order(inc, FALSE, TRUE, FALSE);
1648 if (g_str_has_prefix(word, SPI_PSEUDO_MISO_FIXED)) {
1649 word += strlen(SPI_PSEUDO_MISO_FIXED);
1651 ret = sr_atoul_base(word, &v, &endp, inc->read_text.base);
1656 sr_spew("SPI pseudo: MISO fixed %lu", v);
1657 spi_pseudo_miso_fixed(inc, v);
1660 if (strcmp(word, SPI_PSEUDO_MOSI_MISO) == 0) {
1661 sr_spew("SPI pseudo: MOSI then MISO");
1662 spi_pseudo_data_order(inc, TRUE, TRUE, TRUE);
1665 if (strcmp(word, SPI_PSEUDO_MISO_MOSI) == 0) {
1666 sr_spew("SPI pseudo: MISO then MOSI");
1667 spi_pseudo_data_order(inc, TRUE, TRUE, FALSE);
1670 if (strcmp(word, SPI_PSEUDO_CS_ASSERT) == 0) {
1671 sr_spew("SPI pseudo: CS assert");
1672 spi_pseudo_select_control(inc, TRUE);
1675 if (strcmp(word, SPI_PSEUDO_CS_RELEASE) == 0) {
1676 sr_spew("SPI pseudo: CS release");
1677 /* Release CS. Force IDLE to display the pin change. */
1678 spi_pseudo_select_control(inc, FALSE);
1679 ret = spi_write_frame_patterns(inc, TRUE, FALSE);
1682 ret = send_frame(in);
1687 if (g_str_has_prefix(word, SPI_PSEUDO_CS_NEXT)) {
1688 word += strlen(SPI_PSEUDO_CS_NEXT);
1690 ret = sr_atoul_base(word, &v, &endp, 0);
1695 sr_spew("SPI pseudo: CS auto next %lu", v);
1696 spi_pseudo_auto_select(inc, v);
1699 if (strcmp(word, SPI_PSEUDO_IDLE) == 0) {
1700 sr_spew("SPI pseudo: idle");
1701 ret = spi_write_frame_patterns(inc, TRUE, FALSE);
1704 ret = send_frame(in);
1716 * Create the frame's waveform for the given data value. For bidirectional
1717 * communication multiple routine invocations accumulate data bits, while
1718 * the last invocation completes the frame preparation.
1720 static int spi_proc_value(struct context *inc, uint32_t value)
1722 struct spi_proto_context_t *incs;
1725 gboolean auto_cs_end;
1729 incs = inc->curr_opts.prot_priv;
1732 * Discard previous data when we get here after having completed
1733 * a previous frame. This roundtrip from filling in to clearing
1734 * is required to have the caller emit the waveform that we have
1735 * constructed after receiving data values.
1737 if (spi_value_is_bytes_complete(inc)) {
1738 sr_spew("SPI value: discarding previous data");
1739 spi_value_discard_prev_data(inc);
1743 * Consume the caller provided value. Apply data in the order
1744 * that was configured before.
1747 if (!taken && incs->mosi_first && !incs->has_mosi) {
1748 sr_spew("SPI value: grabbing MOSI value");
1749 incs->mosi_byte = value & 0xff;
1750 incs->has_mosi = TRUE;
1753 if (!taken && !incs->has_miso) {
1754 sr_spew("SPI value: grabbing MISO value");
1755 incs->miso_byte = value & 0xff;
1756 incs->has_miso = TRUE;
1758 if (!taken && !incs->mosi_first && !incs->has_mosi) {
1759 sr_spew("SPI value: grabbing MOSI value");
1760 incs->mosi_byte = value & 0xff;
1761 incs->has_mosi = TRUE;
1766 * Generate the waveform when all data values in a byte time
1767 * were seen (all MOSI and MISO including their being optional
1770 * Optionally automatically release CS after a given number of
1771 * data bytes, when requested by the input stream.
1773 if (!spi_value_is_bytes_complete(inc)) {
1774 sr_spew("SPI value: need more values");
1777 auto_cs_end = spi_auto_select_ends(inc);
1778 sr_spew("SPI value: frame complete, drawing, auto CS %d", auto_cs_end);
1779 ret = spi_write_frame_patterns(inc, FALSE, auto_cs_end);
1785 /* Start/end the logic trace with a few bit times of idle level. */
1786 static int spi_get_idle_capture(struct context *inc,
1787 size_t *bitcount, uint8_t *sample)
1790 /* Describe one byte time of idle level. */
1792 *bitcount = inc->max_frame_bits;
1794 *sample = inc->samples.idle_levels;
1798 /* Arrange for a few samples of idle level between UART frames. */
1799 static int spi_get_idle_interframe(struct context *inc,
1800 size_t *samplecount, uint8_t *sample)
1803 /* Describe four bit times, re-use most recent pin levels. */
1805 *samplecount = inc->curr_opts.samples_per_bit;
1809 *sample = inc->samples.curr_levels;
1813 /* }}} SPI protocol handler */
1814 /* {{{ I2C protocol handler */
1822 #define I2C_PINMASK_SCL (1UL << I2C_PIN_SCL)
1823 #define I2C_PINMASK_SDA (1UL << I2C_PIN_SDA)
1825 /* Arrange for automatic ACK for a given number of data bytes. */
1826 static void i2c_auto_ack_start(struct context *inc, size_t count)
1828 struct i2c_proto_context_t *incs;
1830 incs = inc->curr_opts.prot_priv;
1831 incs->ack_remain = count;
1834 /* Check whether automatic ACK is still applicable. Decrements. */
1835 static gboolean i2c_auto_ack_avail(struct context *inc)
1837 struct i2c_proto_context_t *incs;
1839 incs = inc->curr_opts.prot_priv;
1840 if (!incs->ack_remain)
1843 if (incs->ack_remain--)
1848 /* Occupy the slots where START/STOP would be. Keep current levels. */
1849 static int i2c_write_nothing(struct context *inc)
1854 reps = I2C_BITTIME_QUANTA;
1856 ret = wave_append_buffer(inc);
1865 * Construct a START symbol. Occupy a full bit time in the waveform.
1866 * Can also be used as REPEAT START due to its conservative signalling.
1868 * Definition of START: Falling SDA while SCL is high.
1869 * Repeated START: A START without a preceeding STOP.
1871 static int i2c_write_start(struct context *inc)
1876 * Important! Assumes that either SDA and SCL already are
1877 * high (true when we come here from an idle bus). Or that
1878 * SCL already is low before SDA potentially changes (this
1879 * is true for preceeding START or REPEAT START or DATA BIT
1882 * Implementation detail: This START implementation can be
1883 * used for REPEAT START as well. The signalling sequence is
1884 * conservatively done.
1887 /* Enforce SDA high. */
1888 sample_buffer_raise(inc, I2C_PINMASK_SDA);
1889 ret = wave_append_buffer(inc);
1893 /* Enforce SCL high. */
1894 sample_buffer_raise(inc, I2C_PINMASK_SCL);
1895 ret = wave_append_buffer(inc);
1899 /* Keep high SCL and high SDA for another period. */
1900 ret = wave_append_buffer(inc);
1904 /* Falling SDA while SCL is high. */
1905 sample_buffer_clear(inc, I2C_PINMASK_SDA);
1906 ret = wave_append_buffer(inc);
1910 /* Keep high SCL and low SDA for one more period. */
1911 ret = wave_append_buffer(inc);
1916 * Lower SCL here already. Which kind of prepares DATA BIT
1917 * times (fits a data bit's start condition, does not harm).
1918 * Improves back to back START and (repeated) START as well
1919 * as STOP without preceeding DATA BIT.
1921 sample_buffer_clear(inc, I2C_PINMASK_SCL);
1922 ret = wave_append_buffer(inc);
1930 * Construct a STOP symbol. Occupy a full bit time in the waveform.
1932 * Definition of STOP: Rising SDA while SCL is high.
1934 static int i2c_write_stop(struct context *inc)
1938 /* Enforce SCL low before SDA changes. */
1939 sample_buffer_clear(inc, I2C_PINMASK_SCL);
1940 ret = wave_append_buffer(inc);
1944 /* Enforce SDA low (can change while SCL is low). */
1945 sample_buffer_clear(inc, I2C_PINMASK_SDA);
1946 ret = wave_append_buffer(inc);
1950 /* Rise SCL high while SDA is low. */
1951 sample_buffer_raise(inc, I2C_PINMASK_SCL);
1952 ret = wave_append_buffer(inc);
1956 /* Keep high SCL and low SDA for another period. */
1957 ret = wave_append_buffer(inc);
1962 sample_buffer_raise(inc, I2C_PINMASK_SDA);
1963 ret = wave_append_buffer(inc);
1967 /* Keep high SCL and high SDA for one more periods. */
1968 ret = wave_append_buffer(inc);
1976 * Construct a DATA BIT symbol. Occupy a full bit time in the waveform.
1978 * SDA can change while SCL is low. SDA must be kept while SCL is high.
1980 static int i2c_write_bit(struct context *inc, uint8_t value)
1984 /* Enforce SCL low before SDA changes. */
1985 sample_buffer_clear(inc, I2C_PINMASK_SCL);
1986 ret = wave_append_buffer(inc);
1990 /* Setup SDA pin level while SCL is low. */
1991 sample_buffer_setclr(inc, value, I2C_PINMASK_SDA);
1992 ret = wave_append_buffer(inc);
1996 /* Rising SCL, starting SDA validity. */
1997 sample_buffer_raise(inc, I2C_PINMASK_SCL);
1998 ret = wave_append_buffer(inc);
2002 /* Keep SDA level with high SCL for two more periods. */
2003 ret = wave_append_buffer(inc);
2006 ret = wave_append_buffer(inc);
2010 /* Falling SCL, terminates SDA validity. */
2011 sample_buffer_clear(inc, I2C_PINMASK_SCL);
2012 ret = wave_append_buffer(inc);
2019 /* Create a waveform for the eight data bits and the ACK/NAK slot. */
2020 static int i2c_write_byte(struct context *inc, uint8_t value, uint8_t ack)
2022 size_t bit_mask, bit_value;
2025 /* Keep an empty bit time before the data byte. */
2026 ret = i2c_write_nothing(inc);
2030 /* Send 8 data bits, MSB first. */
2033 bit_value = value & bit_mask;
2035 ret = i2c_write_bit(inc, bit_value);
2040 /* Send ACK, which is low active. NAK is recessive, high. */
2042 ret = i2c_write_bit(inc, bit_value);
2046 /* Keep an empty bit time after the data byte. */
2047 ret = i2c_write_nothing(inc);
2054 /* Send slave address (7bit or 10bit, 1 or 2 bytes). Consumes one ACK. */
2055 static int i2c_send_address(struct sr_input *in, uint16_t addr, gboolean read)
2057 struct context *inc;
2058 struct i2c_frame_fmt_opts *fmt_opts;
2060 uint8_t addr_byte, rw_bit;
2064 fmt_opts = &inc->curr_opts.frame_format.i2c;
2067 rw_bit = read ? 1 : 0;
2068 with_ack = i2c_auto_ack_avail(inc);
2070 if (!fmt_opts->addr_10bit) {
2071 /* 7 bit address, the simple case. */
2072 addr_byte = addr & 0x7f;
2074 addr_byte |= rw_bit;
2075 sr_spew("I2C 7bit address, byte 0x%" PRIx8, addr_byte);
2076 ret = wave_clear_sequence(inc);
2079 ret = i2c_write_byte(inc, addr_byte, with_ack);
2082 ret = send_frame(in);
2087 * 10 bit address, need to write two bytes: First byte
2088 * with prefix 0xf0, upper most 2 address bits, and R/W.
2089 * Second byte with lower 8 address bits.
2091 addr_byte = addr >> 8;
2094 addr_byte |= rw_bit;
2095 sr_spew("I2C 10bit address, byte 0x%" PRIx8, addr_byte);
2096 ret = wave_clear_sequence(inc);
2099 ret = i2c_write_byte(inc, addr_byte, with_ack);
2102 ret = send_frame(in);
2106 addr_byte = addr & 0xff;
2107 sr_spew("I2C 10bit address, byte 0x%" PRIx8, addr_byte);
2108 ret = wave_clear_sequence(inc);
2111 ret = i2c_write_byte(inc, addr_byte, with_ack);
2114 ret = send_frame(in);
2122 /* I2C specific options and frame format check. */
2123 static int i2c_check_opts(struct context *inc)
2125 struct i2c_frame_fmt_opts *fmt_opts;
2126 const char *fmt_text;
2128 size_t opt_count, opt_idx;
2133 fmt_opts = &inc->curr_opts.frame_format.i2c;
2135 /* Apply defaults before reading external specs. */
2136 memset(fmt_opts, 0, sizeof(*fmt_opts));
2137 fmt_opts->addr_10bit = FALSE;
2139 /* Provide a default I2C frame format. */
2140 fmt_text = inc->curr_opts.fmt_text;
2141 if (!fmt_text || !*fmt_text)
2142 fmt_text = I2C_DFLT_FRAMEFMT;
2143 sr_dbg("I2C frame format: %s.", fmt_text);
2145 /* Accept comma separated key=value pairs of specs. */
2146 opts = g_strsplit_set(fmt_text, ", ", 0);
2147 opt_count = g_strv_length(opts);
2148 for (opt_idx = 0; opt_idx < opt_count; opt_idx++) {
2149 opt = opts[opt_idx];
2152 sr_spew("I2C format option: %s.", opt);
2153 if (strcmp(opt, I2C_FORMAT_ADDR_7BIT) == 0) {
2154 sr_spew("I2C address: 7 bit");
2155 fmt_opts->addr_10bit = FALSE;
2158 if (strcmp(opt, I2C_FORMAT_ADDR_10BIT) == 0) {
2159 sr_spew("I2C address: 10 bit");
2160 fmt_opts->addr_10bit = TRUE;
2167 /* Get the total slot count. Leave plenty room for convenience. */
2169 total_bits += I2C_BITTIME_SLOTS;
2170 total_bits *= I2C_BITTIME_QUANTA;
2171 total_bits += I2C_ADD_IDLESLOTS;
2173 sr_dbg("I2C frame: total bits %lu.", total_bits);
2174 if (total_bits > I2C_MAX_WAVELEN)
2176 inc->max_frame_bits = total_bits;
2182 * Don't bother with wide and narrow slots, just assume equal size for
2183 * them all. Edges will occupy exactly one sample, then levels are kept.
2184 * This protocol handler's oversampling should be sufficient for decoders
2185 * to extract the content from generated waveforms.
2187 * Start with high levels on SCL and SDA for an idle bus condition.
2189 static int i2c_config_frame(struct context *inc)
2191 struct i2c_proto_context_t *incs;
2197 incs = inc->curr_opts.prot_priv;
2199 memset(incs, 0, sizeof(*incs));
2200 incs->ack_remain = 0;
2203 * Adjust all time slots since they represent a smaller quanta
2204 * of an I2C bit time.
2206 for (bit_idx = 0; bit_idx < inc->max_frame_bits; bit_idx++) {
2207 inc->bit_scale[bit_idx].div = I2C_BITTIME_QUANTA;
2211 sample |= I2C_PINMASK_SCL;
2212 sample |= I2C_PINMASK_SDA;
2213 sample_buffer_preset(inc, sample);
2219 * Process protocol dependent pseudo comments. Can affect future frame
2220 * construction and submission, or can immediately emit "inter frame"
2221 * bit patterns like START/STOP control. Use wide waveforms for these
2222 * transfer controls, put the special symbol nicely centered. Supports
2223 * users during interactive exploration of generated waveforms.
2225 static int i2c_proc_pseudo(struct sr_input *in, char *line)
2227 struct context *inc;
2236 word = sr_text_next_word(line, &line);
2241 sr_spew("I2C pseudo: word %s", word);
2242 if (strcmp(word, I2C_PSEUDO_START) == 0) {
2243 sr_spew("I2C pseudo: send START");
2244 ret = wave_clear_sequence(inc);
2247 bits = I2C_BITTIME_SLOTS / 2;
2249 ret = i2c_write_nothing(inc);
2253 ret = i2c_write_start(inc);
2256 bits = I2C_BITTIME_SLOTS / 2;
2258 ret = i2c_write_nothing(inc);
2262 ret = send_frame(in);
2267 if (strcmp(word, I2C_PSEUDO_REP_START) == 0) {
2268 sr_spew("I2C pseudo: send REPEAT START");
2269 ret = wave_clear_sequence(inc);
2272 bits = I2C_BITTIME_SLOTS / 2;
2274 ret = i2c_write_nothing(inc);
2278 ret = i2c_write_start(inc);
2281 bits = I2C_BITTIME_SLOTS / 2;
2283 ret = i2c_write_nothing(inc);
2287 ret = send_frame(in);
2292 if (strcmp(word, I2C_PSEUDO_STOP) == 0) {
2293 sr_spew("I2C pseudo: send STOP");
2294 ret = wave_clear_sequence(inc);
2297 bits = I2C_BITTIME_SLOTS / 2;
2299 ret = i2c_write_nothing(inc);
2303 ret = i2c_write_stop(inc);
2306 bits = I2C_BITTIME_SLOTS / 2;
2308 ret = i2c_write_nothing(inc);
2312 ret = send_frame(in);
2317 if (g_str_has_prefix(word, I2C_PSEUDO_ADDR_WRITE)) {
2318 word += strlen(I2C_PSEUDO_ADDR_WRITE);
2320 ret = sr_atoul_base(word, &v, &endp, 0);
2325 sr_spew("I2C pseudo: addr write %lu", v);
2326 ret = i2c_send_address(in, v, FALSE);
2331 if (g_str_has_prefix(word, I2C_PSEUDO_ADDR_READ)) {
2332 word += strlen(I2C_PSEUDO_ADDR_READ);
2334 ret = sr_atoul_base(word, &v, &endp, 0);
2339 sr_spew("I2C pseudo: addr read %lu", v);
2340 ret = i2c_send_address(in, v, TRUE);
2345 if (g_str_has_prefix(word, I2C_PSEUDO_ACK_NEXT)) {
2346 word += strlen(I2C_PSEUDO_ACK_NEXT);
2348 ret = sr_atoul_base(word, &v, &endp, 0);
2353 sr_spew("i2c pseudo: ack next %lu", v);
2354 i2c_auto_ack_start(inc, v);
2357 if (strcmp(word, I2C_PSEUDO_ACK_ONCE) == 0) {
2358 sr_spew("i2c pseudo: ack once");
2359 i2c_auto_ack_start(inc, 1);
2369 * Create the frame's waveform for the given data value. Automatically
2370 * track ACK bits, Fallback to NAK when externally specified ACK counts
2371 * have expired. The caller sends the waveform that we created.
2373 static int i2c_proc_value(struct context *inc, uint32_t value)
2381 with_ack = i2c_auto_ack_avail(inc);
2383 ret = wave_clear_sequence(inc);
2386 ret = i2c_write_byte(inc, value, with_ack);
2393 /* Start/end the logic trace with a few bit times of idle level. */
2394 static int i2c_get_idle_capture(struct context *inc,
2395 size_t *bitcount, uint8_t *sample)
2398 /* Describe a byte's time of idle level. */
2400 *bitcount = I2C_BITTIME_SLOTS;
2402 *sample = inc->samples.idle_levels;
2406 /* Arrange for a few samples of idle level between UART frames. */
2407 static int i2c_get_idle_interframe(struct context *inc,
2408 size_t *samplecount, uint8_t *sample)
2412 * The space around regular bytes already is sufficient. We
2413 * don't need to generate an inter-frame gap, but the code is
2414 * prepared to in case we want to in the future.
2417 *samplecount = inc->curr_opts.samples_per_bit;
2421 *sample = inc->samples.curr_levels;
2425 /* }}} I2C protocol handler */
2426 /* {{{ protocol dispatching */
2429 * The list of supported protocols and their handlers, including
2430 * protocol specific defaults. The first item after the NONE slot
2431 * is the default protocol, and takes effect in the absence of any
2432 * user provided or file content provided spec.
2434 static const struct proto_handler_t protocols[PROTO_TYPE_COUNT] = {
2435 [PROTO_TYPE_UART] = {
2438 UART_DFLT_SAMPLERATE,
2439 UART_DFLT_BITRATE, UART_DFLT_FRAMEFMT,
2443 1, (const char *[]){
2444 [UART_PIN_RXTX] = "rxtx",
2452 uart_get_idle_capture,
2453 uart_get_idle_interframe,
2455 [PROTO_TYPE_SPI] = {
2458 SPI_DFLT_SAMPLERATE,
2459 SPI_DFLT_BITRATE, SPI_DFLT_FRAMEFMT,
2463 4, (const char *[]){
2464 [SPI_PIN_SCK] = "sck",
2465 [SPI_PIN_MISO] = "miso",
2466 [SPI_PIN_MOSI] = "mosi",
2467 [SPI_PIN_CS] = "cs",
2470 sizeof(struct spi_proto_context_t),
2475 spi_get_idle_capture,
2476 spi_get_idle_interframe,
2478 [PROTO_TYPE_I2C] = {
2481 I2C_DFLT_SAMPLERATE,
2482 I2C_DFLT_BITRATE, I2C_DFLT_FRAMEFMT,
2486 2, (const char *[]){
2487 [I2C_PIN_SCL] = "scl",
2488 [I2C_PIN_SDA] = "sda",
2491 sizeof(struct i2c_proto_context_t),
2496 i2c_get_idle_capture,
2497 i2c_get_idle_interframe,
2501 static int lookup_protocol_name(struct context *inc)
2504 const struct proto_handler_t *handler;
2509 * Silence compiler warnings. Protocol handlers are free to use
2510 * several alternative sets of primitives for their operation.
2511 * Not using part of the API is nothing worth warning about.
2513 (void)sample_buffer_assign;
2517 inc->curr_opts.protocol_type = PROTO_TYPE_NONE;
2518 inc->curr_opts.prot_hdl = NULL;
2520 name = inc->curr_opts.proto_name;
2521 if (!name || !*name) {
2522 /* Fallback to first item after NONE slot. */
2523 handler = &protocols[PROTO_TYPE_NONE + 1];
2524 name = handler->name;
2527 for (idx = 0; idx < ARRAY_SIZE(protocols); idx++) {
2528 if (idx == PROTO_TYPE_NONE)
2530 handler = &protocols[idx];
2531 if (!handler->name || !*handler->name)
2533 if (strcmp(name, handler->name) != 0)
2535 inc->curr_opts.protocol_type = idx;
2536 inc->curr_opts.prot_hdl = handler;
2537 if (handler->priv_size) {
2538 priv = g_malloc0(handler->priv_size);
2540 return SR_ERR_MALLOC;
2541 inc->curr_opts.prot_priv = priv;
2549 /* }}} protocol dispatching */
2550 /* {{{ text/binary input file reader */
2553 * Checks for UTF BOM, removes it when found at the start of the buffer.
2555 * @param[in] buf The accumulated input buffer.
2557 static void check_remove_bom(GString *buf)
2559 static const char *bom_text = "\xef\xbb\xbf";
2561 if (buf->len < strlen(bom_text))
2563 if (strncmp(buf->str, bom_text, strlen(bom_text)) != 0)
2565 g_string_erase(buf, 0, strlen(bom_text));
2569 * Checks for presence of a caption, yields the position after its text line.
2571 * @param[in] buf The accumulated input buffer.
2572 * @param[in] caption The text to search for (NUL terminated ASCII literal).
2573 * @param[in] max_pos The maximum length to search for.
2575 * @returns The position after the text line which contains the caption.
2576 * Or #NULL when either the caption or the end-of-line was not found.
2578 static char *have_text_line(GString *buf, const char *caption, size_t max_pos)
2580 size_t cap_len, rem_len;
2581 char *p_read, *p_found;
2583 cap_len = strlen(caption);
2587 /* Search for the occurance of the caption itself. */
2589 /* Caption must be at the start of the buffer. */
2590 if (rem_len < cap_len)
2592 if (strncmp(p_read, caption, cap_len) != 0)
2595 /* Caption can be anywhere up to a max position. */
2596 p_found = g_strstr_len(p_read, rem_len, caption);
2599 /* Pretend that caption had been rather long. */
2600 cap_len += p_found - p_read;
2604 * Advance over the caption. Advance over end-of-line. Supports
2605 * several end-of-line conditions, but rejects unexpected trailer
2606 * after the caption and before the end-of-line. Always wants LF.
2610 while (rem_len && *p_read != '\n' && g_ascii_isspace(*p_read)) {
2614 if (rem_len && *p_read != '\n' && *p_read == '\r') {
2618 if (rem_len && *p_read == '\n') {
2628 * Checks for the presence of the magic string at the start of the file.
2630 * @param[in] buf The accumulated input buffer.
2631 * @param[out] next_pos The text after the magic text line.
2633 * @returns Boolean whether the magic was found.
2635 * This implementation assumes that the magic file type marker never gets
2636 * split across receive chunks.
2638 static gboolean have_magic(GString *buf, char **next_pos)
2645 next_line = have_text_line(buf, MAGIC_FILE_TYPE, 0);
2650 *next_pos = next_line;
2656 * Checks for the presence of the header section at the start of the file.
2658 * @param[in] buf The accumulated input buffer.
2659 * @param[out] next_pos The text after the header section.
2661 * @returns A negative value when the answer is yet unknown (insufficient
2662 * input data). Or boolean 0/1 when the header was found absent/present.
2664 * The caller is supposed to have checked for and removed the magic text
2665 * for the file type. This routine expects to find the header section
2666 * boundaries right at the start of the input buffer.
2668 * This implementation assumes that the header start marker never gets
2669 * split across receive chunks.
2671 static int have_header(GString *buf, char **next_pos)
2673 char *after_start, *after_end;
2678 after_start = have_text_line(buf, TEXT_HEAD_START, 0);
2682 after_end = have_text_line(buf, TEXT_HEAD_END, buf->len);
2687 *next_pos = after_end;
2692 * Implementation detail: Most parse routines merely accept an input
2693 * string or at most convert text to numbers. Actual processing of the
2694 * values or constraints checks are done later when the header section
2695 * ended and all data was seen, regardless of order of appearance.
2698 static int parse_samplerate(struct context *inc, const char *text)
2703 ret = sr_parse_sizestring(text, &rate);
2707 inc->curr_opts.samplerate = rate;
2712 static int parse_bitrate(struct context *inc, const char *text)
2717 ret = sr_parse_sizestring(text, &rate);
2721 inc->curr_opts.bitrate = rate;
2726 static int parse_protocol(struct context *inc, const char *line)
2729 if (!line || !*line)
2732 if (inc->curr_opts.proto_name) {
2733 free(inc->curr_opts.proto_name);
2734 inc->curr_opts.proto_name = NULL;
2736 inc->curr_opts.proto_name = g_strdup(line);
2737 if (!inc->curr_opts.proto_name)
2738 return SR_ERR_MALLOC;
2739 line = inc->curr_opts.proto_name;
2744 static int parse_frameformat(struct context *inc, const char *line)
2747 if (!line || !*line)
2750 if (inc->curr_opts.fmt_text) {
2751 free(inc->curr_opts.fmt_text);
2752 inc->curr_opts.fmt_text = NULL;
2754 inc->curr_opts.fmt_text = g_strdup(line);
2755 if (!inc->curr_opts.fmt_text)
2756 return SR_ERR_MALLOC;
2757 line = inc->curr_opts.fmt_text;
2762 static int parse_textinput(struct context *inc, const char *text)
2766 if (!text || !*text)
2769 is_text = sr_parse_boolstring(text);
2770 inc->curr_opts.textinput = is_text ? INPUT_TEXT : INPUT_BYTES;
2774 static int parse_header_line(struct context *inc, const char *line)
2777 /* Silently ignore comment lines. Also covers start/end markers. */
2778 if (strncmp(line, TEXT_COMM_LEADER, strlen(TEXT_COMM_LEADER)) == 0)
2781 if (strncmp(line, LABEL_SAMPLERATE, strlen(LABEL_SAMPLERATE)) == 0) {
2782 line += strlen(LABEL_SAMPLERATE);
2783 return parse_samplerate(inc, line);
2785 if (strncmp(line, LABEL_BITRATE, strlen(LABEL_BITRATE)) == 0) {
2786 line += strlen(LABEL_BITRATE);
2787 return parse_bitrate(inc, line);
2789 if (strncmp(line, LABEL_PROTOCOL, strlen(LABEL_PROTOCOL)) == 0) {
2790 line += strlen(LABEL_PROTOCOL);
2791 return parse_protocol(inc, line);
2793 if (strncmp(line, LABEL_FRAMEFORMAT, strlen(LABEL_FRAMEFORMAT)) == 0) {
2794 line += strlen(LABEL_FRAMEFORMAT);
2795 return parse_frameformat(inc, line);
2797 if (strncmp(line, LABEL_TEXTINPUT, strlen(LABEL_TEXTINPUT)) == 0) {
2798 line += strlen(LABEL_TEXTINPUT);
2799 return parse_textinput(inc, line);
2802 /* Unsupported directive. */
2803 sr_err("Unsupported header directive: %s.", line);
2808 static int parse_header(struct context *inc, GString *buf, size_t hdr_len)
2811 char *curr, *next, *line;
2816 /* The caller determined where the header ends. Read up to there. */
2819 while (curr && remain) {
2820 /* Get another text line. Skip empty lines. */
2821 line = sr_text_next_line(curr, remain, &next, NULL);
2825 remain -= next - curr;
2831 /* Process the non-empty file header text line. */
2832 sr_dbg("Header line: %s", line);
2833 ret = parse_header_line(inc, line);
2841 /* Process input text reader specific pseudo comment. */
2842 static int process_pseudo_textinput(struct sr_input *in, char *line)
2844 struct context *inc;
2852 word = sr_text_next_word(line, &line);
2857 if (g_str_has_prefix(word, TEXT_INPUT_RADIX)) {
2858 word += strlen(TEXT_INPUT_RADIX);
2860 ret = sr_atoul_base(word, &v, &endp, 10);
2863 inc->read_text.base = v;
2872 /* Process a line of input text. */
2873 static int process_textline(struct sr_input *in, char *line)
2875 struct context *inc;
2876 const struct proto_handler_t *handler;
2877 gboolean is_comm, is_pseudo;
2878 char *p, *word, *endp;
2879 unsigned long value;
2883 handler = inc->curr_opts.prot_hdl;
2886 * Check for comments, including pseudo-comments with protocol
2887 * specific or text reader specific instructions. It's essential
2888 * to check for "# ${PROTO}:" last, because the implementation
2889 * of the check advances the read position, cannot rewind when
2890 * detection fails. But we know that it is a comment and was not
2891 * a pseudo-comment. So any non-matching data just gets discarded.
2892 * Matching data gets processed (when handlers exist).
2894 is_comm = g_str_has_prefix(line, TEXT_COMM_LEADER);
2896 line += strlen(TEXT_COMM_LEADER);
2897 while (isspace(*line))
2899 is_pseudo = g_str_has_prefix(line, TEXT_INPUT_PREFIX);
2901 line += strlen(TEXT_INPUT_PREFIX);
2902 while (isspace(*line))
2904 sr_dbg("pseudo comment, textinput: %s", line);
2905 line = sr_text_trim_spaces(line);
2906 return process_pseudo_textinput(in, line);
2908 is_pseudo = g_str_has_prefix(line, handler->name);
2910 line += strlen(handler->name);
2911 is_pseudo = *line == ':';
2916 while (isspace(*line))
2918 sr_dbg("pseudo comment, protocol: %s", line);
2919 if (!handler->proc_pseudo)
2921 return handler->proc_pseudo(in, line);
2923 sr_spew("comment, skipping: %s", line);
2928 * Non-empty non-comment lines carry protocol values.
2929 * (Empty lines are handled transparently when they get here.)
2930 * Accept comma and semicolon separators for user convenience.
2931 * Convert text according to previously received instructions.
2932 * Pass the values to the protocol handler. Flush waveforms
2933 * when handlers state that their construction has completed.
2935 sr_spew("got values line: %s", line);
2936 for (p = line; *p; p++) {
2937 if (*p == ',' || *p == ';')
2941 word = sr_text_next_word(line, &line);
2946 /* Get another numeric value. */
2948 ret = sr_atoul_base(word, &value, &endp, inc->read_text.base);
2953 sr_spew("got a value, text [%s] -> number [%lu]", word, value);
2954 /* Forward the value to the protocol handler. */
2956 if (handler->proc_value)
2957 ret = handler->proc_value(inc, value);
2960 /* Flush the waveform when handler signals completion. */
2963 ret = send_frame(in);
2966 ret = send_idle_interframe(inc);
2974 /* }}} text/binary input file reader */
2977 * Consistency check of all previously received information. Combines
2978 * the data file's optional header section, as well as user provided
2979 * options that were specified during input module creation. User specs
2980 * take precedence over file content.
2982 static int check_header_user_options(struct context *inc)
2985 const struct proto_handler_t *handler;
2988 enum textinput_t is_text;
2993 /* Prefer user specs over file content. */
2994 rate = inc->user_opts.samplerate;
2996 sr_dbg("Using user samplerate %" PRIu64 ".", rate);
2997 inc->curr_opts.samplerate = rate;
2999 rate = inc->user_opts.bitrate;
3001 sr_dbg("Using user bitrate %" PRIu64 ".", rate);
3002 inc->curr_opts.bitrate = rate;
3004 text = inc->user_opts.proto_name;
3005 if (text && *text) {
3006 sr_dbg("Using user protocol %s.", text);
3007 ret = parse_protocol(inc, text);
3011 text = inc->user_opts.fmt_text;
3012 if (text && *text) {
3013 sr_dbg("Using user frame format %s.", text);
3014 ret = parse_frameformat(inc, text);
3018 is_text = inc->user_opts.textinput;
3020 sr_dbg("Using user textinput %d.", is_text);
3021 inc->curr_opts.textinput = is_text;
3024 /* Lookup the protocol (with fallback). Use protocol's defaults. */
3025 text = inc->curr_opts.proto_name;
3026 ret = lookup_protocol_name(inc);
3027 handler = inc->curr_opts.prot_hdl;
3028 if (ret != SR_OK || !handler) {
3029 sr_err("Unsupported protocol: %s.", text);
3032 text = handler->name;
3033 if (!inc->curr_opts.proto_name && text) {
3034 sr_dbg("Using protocol handler name %s.", text);
3035 ret = parse_protocol(inc, text);
3039 rate = handler->dflt.samplerate;
3040 if (!inc->curr_opts.samplerate && rate) {
3041 sr_dbg("Using protocol handler samplerate %" PRIu64 ".", rate);
3042 inc->curr_opts.samplerate = rate;
3044 rate = handler->dflt.bitrate;
3045 if (!inc->curr_opts.bitrate && rate) {
3046 sr_dbg("Using protocol handler bitrate %" PRIu64 ".", rate);
3047 inc->curr_opts.bitrate = rate;
3049 text = handler->dflt.frame_format;
3050 if (!inc->curr_opts.fmt_text && text && *text) {
3051 sr_dbg("Using protocol handler frame format %s.", text);
3052 ret = parse_frameformat(inc, text);
3056 is_text = handler->dflt.textinput;
3057 if (!inc->curr_opts.textinput && is_text) {
3058 sr_dbg("Using protocol handler text format %d.", is_text);
3059 inc->curr_opts.textinput = is_text;
3062 if (!inc->curr_opts.samplerate) {
3063 sr_err("Need a samplerate.");
3066 if (!inc->curr_opts.bitrate) {
3067 sr_err("Need a protocol bitrate.");
3071 if (inc->curr_opts.samplerate < inc->curr_opts.bitrate) {
3072 sr_err("Bitrate cannot exceed samplerate.");
3075 if (inc->curr_opts.samplerate / inc->curr_opts.bitrate < 3)
3076 sr_warn("Low oversampling, consider higher samplerate.");
3077 if (inc->curr_opts.prot_hdl->check_opts) {
3078 ret = inc->curr_opts.prot_hdl->check_opts(inc);
3080 sr_err("Options failed the protocol's check.");
3088 static int create_channels(struct sr_input *in)
3090 struct context *inc;
3091 struct sr_dev_inst *sdi;
3092 const struct proto_handler_t *handler;
3102 handler = inc->curr_opts.prot_hdl;
3104 for (index = 0; index < handler->chans.count; index++) {
3105 name = handler->chans.names[index];
3106 sr_dbg("Channel %zu name %s.", index, name);
3107 sr_channel_new(sdi, index, SR_CHANNEL_LOGIC, TRUE, name);
3110 inc->feed_logic = feed_queue_logic_alloc(in->sdi,
3111 CHUNK_SIZE, sizeof(uint8_t));
3112 if (!inc->feed_logic) {
3113 sr_err("Cannot create session feed.");
3114 return SR_ERR_MALLOC;
3121 * Keep track of a previously created channel list, in preparation of
3122 * re-reading the input file. Gets called from reset()/cleanup() paths.
3124 static void keep_header_for_reread(const struct sr_input *in)
3126 struct context *inc;
3130 g_slist_free_full(inc->prev.sr_groups, sr_channel_group_free_cb);
3131 inc->prev.sr_groups = in->sdi->channel_groups;
3132 in->sdi->channel_groups = NULL;
3134 g_slist_free_full(inc->prev.sr_channels, sr_channel_free_cb);
3135 inc->prev.sr_channels = in->sdi->channels;
3136 in->sdi->channels = NULL;
3140 * Check whether the input file is being re-read, and refuse operation
3141 * when essential parameters of the acquisition have changed in ways
3142 * that are unexpected to calling applications. Gets called after the
3143 * file header got parsed (again).
3145 * Changing the channel list across re-imports of the same file is not
3146 * supported, by design and for valid reasons, see bug #1215 for details.
3147 * Users are expected to start new sessions when they change these
3148 * essential parameters in the acquisition's setup. When we accept the
3149 * re-read file, then make sure to keep using the previous channel list,
3150 * applications may still reference them.
3152 static gboolean check_header_in_reread(const struct sr_input *in)
3154 struct context *inc;
3161 if (!inc->prev.sr_channels)
3164 if (sr_channel_lists_differ(inc->prev.sr_channels, in->sdi->channels)) {
3165 sr_err("Channel list change not supported for file re-read.");
3169 g_slist_free_full(in->sdi->channel_groups, sr_channel_group_free_cb);
3170 in->sdi->channel_groups = inc->prev.sr_groups;
3171 inc->prev.sr_groups = NULL;
3173 g_slist_free_full(in->sdi->channels, sr_channel_free_cb);
3174 in->sdi->channels = inc->prev.sr_channels;
3175 inc->prev.sr_channels = NULL;
3180 /* Process another chunk of accumulated input data. */
3181 static int process_buffer(struct sr_input *in, gboolean is_eof)
3183 struct context *inc;
3187 const struct proto_handler_t *handler;
3194 handler = inc->curr_opts.prot_hdl;
3197 * Send feed header and samplerate once before any sample data.
3198 * Communicate an idle period before the first generated frame.
3200 if (!inc->started) {
3201 std_session_send_df_header(in->sdi);
3202 gvar = g_variant_new_uint64(inc->curr_opts.samplerate);
3203 ret = sr_session_send_meta(in->sdi, SR_CONF_SAMPLERATE, gvar);
3204 inc->started = TRUE;
3208 ret = send_idle_capture(inc);
3214 * Force proper line termination when EOF is seen and the data
3215 * is in text format. This does not affect binary input, while
3216 * properly terminated text input does not suffer from another
3217 * line feed, because empty lines are considered acceptable.
3218 * Increases robustness for text input from broken generators
3219 * (popular editors which don't terminate the last line).
3221 if (inc->curr_opts.textinput == INPUT_TEXT && is_eof) {
3222 g_string_append_c(buf, '\n');
3226 * For text input: Scan for the completion of another text line.
3227 * Process its values (or pseudo comments). Skip comment lines.
3229 if (inc->curr_opts.textinput == INPUT_TEXT) do {
3230 /* Get another line of text. */
3232 line = sr_text_next_line(buf->str, buf->len, &next, &seen);
3235 /* Process non-empty input lines. */
3236 ret = *line ? process_textline(in, line) : 0;
3239 /* Discard processed input text. */
3240 g_string_erase(buf, 0, seen);
3244 * For binary input: Pass data values (individual bytes) to the
3245 * creation of protocol frames. Send the frame's waveform to
3246 * logic channels in the session feed when the protocol handler
3247 * signals the completion of another waveform (zero return value).
3248 * Non-zero positive values translate to "need more input data".
3249 * Negative values signal fatal errors. Remove processed input
3250 * data from the receive buffer.
3252 if (inc->curr_opts.textinput == INPUT_BYTES) {
3254 while (seen < buf->len) {
3255 sample = buf->str[seen++];
3257 if (handler->proc_value)
3258 ret = handler->proc_value(inc, sample);
3263 ret = send_frame(in);
3266 ret = send_idle_interframe(inc);
3270 g_string_erase(buf, 0, seen);
3273 /* Send idle level, and flush when end of input data is seen. */
3276 sr_warn("Unprocessed input data remains.");
3278 ret = send_idle_capture(inc);
3282 ret = feed_queue_logic_flush(inc->feed_logic);
3290 static int format_match(GHashTable *metadata, unsigned int *confidence)
3292 GString *buf, *tmpbuf;
3295 buf = g_hash_table_lookup(metadata,
3296 GINT_TO_POINTER(SR_INPUT_META_HEADER));
3297 tmpbuf = g_string_new_len(buf->str, buf->len);
3299 check_remove_bom(tmpbuf);
3300 has_magic = have_magic(tmpbuf, NULL);
3301 g_string_free(tmpbuf, TRUE);
3310 static int init(struct sr_input *in, GHashTable *options)
3312 struct context *inc;
3318 in->sdi = g_malloc0(sizeof(*in->sdi));
3319 inc = g_malloc0(sizeof(*inc));
3323 * Store user specified options for later reference.
3325 * TODO How to most appropriately hook up size strings with the
3326 * input module's defaults, and applications and their input
3329 gvar = g_hash_table_lookup(options, "samplerate");
3331 rate = g_variant_get_uint64(gvar);
3333 sr_dbg("User samplerate %" PRIu64 ".", rate);
3334 inc->user_opts.samplerate = rate;
3337 gvar = g_hash_table_lookup(options, "bitrate");
3339 rate = g_variant_get_uint64(gvar);
3341 sr_dbg("User bitrate %" PRIu64 ".", rate);
3342 inc->user_opts.bitrate = rate;
3345 gvar = g_hash_table_lookup(options, "protocol");
3347 copy = g_strdup(g_variant_get_string(gvar, NULL));
3349 return SR_ERR_MALLOC;
3351 sr_dbg("User protocol %s.", copy);
3352 inc->user_opts.proto_name = copy;
3355 gvar = g_hash_table_lookup(options, "frameformat");
3357 copy = g_strdup(g_variant_get_string(gvar, NULL));
3359 return SR_ERR_MALLOC;
3361 sr_dbg("User frame format %s.", copy);
3362 inc->user_opts.fmt_text = copy;
3365 inc->user_opts.textinput = INPUT_UNSPEC;
3366 gvar = g_hash_table_lookup(options, "textinput");
3368 text = g_variant_get_string(gvar, NULL);
3373 sr_dbg("User text input %s.", text);
3374 if (strcmp(text, input_format_texts[INPUT_UNSPEC]) == 0) {
3375 inc->user_opts.textinput = INPUT_UNSPEC;
3376 } else if (strcmp(text, input_format_texts[INPUT_BYTES]) == 0) {
3377 inc->user_opts.textinput = INPUT_BYTES;
3378 } else if (strcmp(text, input_format_texts[INPUT_TEXT]) == 0) {
3379 inc->user_opts.textinput = INPUT_TEXT;
3388 static int receive(struct sr_input *in, GString *buf)
3390 struct context *inc;
3391 char *after_magic, *after_header;
3398 * Accumulate all input chunks, potential deferred processing.
3400 * Remove an optional BOM at the very start of the input stream.
3401 * BEWARE! This may affect binary input, and we cannot tell if
3402 * the input is text or binary at this stage. Though probability
3403 * for this issue is rather low. Workarounds are available (put
3404 * another values before the first data which happens to match
3405 * the BOM pattern, provide text input instead).
3407 g_string_append_len(in->buf, buf->str, buf->len);
3408 if (!inc->scanned_magic)
3409 check_remove_bom(in->buf);
3412 * Must complete reception of the (optional) header first. Both
3413 * end of header and absence of header will: Check options that
3414 * were seen so far, then start processing the data part.
3416 if (!inc->got_header) {
3417 /* Check for magic file type marker. */
3418 if (!inc->scanned_magic) {
3419 inc->has_magic = have_magic(in->buf, &after_magic);
3420 inc->scanned_magic = TRUE;
3421 if (inc->has_magic) {
3422 consumed = after_magic - in->buf->str;
3423 sr_dbg("File format magic found (%zu).", consumed);
3424 g_string_erase(in->buf, 0, consumed);
3428 /* Complete header reception and processing. */
3429 if (inc->has_magic) {
3430 ret = have_header(in->buf, &after_header);
3433 inc->has_header = ret;
3434 if (inc->has_header) {
3435 consumed = after_header - in->buf->str;
3436 sr_dbg("File header found (%zu), processing.", consumed);
3437 ret = parse_header(inc, in->buf, consumed);
3440 g_string_erase(in->buf, 0, consumed);
3443 inc->got_header = TRUE;
3446 * Postprocess the combination of all options. Create
3447 * logic channels, prepare resources for data processing.
3449 ret = check_header_user_options(inc);
3452 ret = create_channels(in);
3455 if (!check_header_in_reread(in))
3457 ret = alloc_frame_storage(inc);
3460 ret = assign_bit_widths(inc);
3464 /* Notify the frontend that sdi is ready. */
3465 in->sdi_ready = TRUE;
3470 * Process the input file's data section after the header section
3471 * was received and processed.
3473 ret = process_buffer(in, FALSE);
3478 static int end(struct sr_input *in)
3480 struct context *inc;
3485 /* Must complete processing of previously received chunks. */
3486 if (in->sdi_ready) {
3487 ret = process_buffer(in, TRUE);
3492 /* Must send DF_END when DF_HEADER was sent before. */
3494 ret = std_session_send_df_end(in->sdi);
3502 static void cleanup(struct sr_input *in)
3504 struct context *inc;
3508 keep_header_for_reread(in);
3510 g_free(inc->curr_opts.proto_name);
3511 inc->curr_opts.proto_name = NULL;
3512 g_free(inc->curr_opts.fmt_text);
3513 inc->curr_opts.fmt_text = NULL;
3514 g_free(inc->curr_opts.prot_priv);
3515 inc->curr_opts.prot_priv = NULL;
3516 feed_queue_logic_free(inc->feed_logic);
3517 inc->feed_logic = NULL;
3518 g_free(inc->sample_edges);
3519 inc->sample_edges = NULL;
3520 g_free(inc->sample_widths);
3521 inc->sample_widths = NULL;
3522 g_free(inc->sample_levels);
3523 inc->sample_levels = NULL;
3524 g_free(inc->bit_scale);
3525 inc->bit_scale = NULL;
3528 static int reset(struct sr_input *in)
3530 struct context *inc;
3531 struct user_opts_t save_user_opts;
3532 struct proto_prev save_chans;
3536 /* Release previously allocated resources. */
3538 g_string_truncate(in->buf, 0);
3540 /* Restore part of the context, init() won't run again. */
3541 save_user_opts = inc->user_opts;
3542 save_chans = inc->prev;
3543 memset(inc, 0, sizeof(*inc));
3544 inc->user_opts = save_user_opts;
3545 inc->prev = save_chans;
3550 enum proto_option_t {
3559 static struct sr_option options[] = {
3560 [OPT_SAMPLERATE] = {
3561 "samplerate", "Logic data samplerate",
3562 "Samplerate of generated logic traces",
3566 "bitrate", "Protocol bitrate",
3567 "Bitrate used in protocol's communication",
3571 "protocol", "Protocol type",
3572 "The type of protocol to generate waveforms for",
3575 [OPT_FRAME_FORMAT] = {
3576 "frameformat", "Protocol frame format",
3577 "Textual description of the protocol's frame format",
3581 "textinput", "Input data is in text format",
3582 "Input is not data bytes, but text formatted values",
3585 [OPT_MAX] = ALL_ZERO,
3588 static const struct sr_option *get_options(void)
3591 enum proto_type_t p_idx;
3592 enum textinput_t t_idx;
3598 options[OPT_SAMPLERATE].def = g_variant_ref_sink(g_variant_new_uint64(0));
3599 options[OPT_BITRATE].def = g_variant_ref_sink(g_variant_new_uint64(0));
3600 options[OPT_PROTOCOL].def = g_variant_ref_sink(g_variant_new_string(""));
3602 for (p_idx = 0; p_idx < ARRAY_SIZE(protocols); p_idx++) {
3603 s = protocols[p_idx].name;
3606 l = g_slist_append(l, g_variant_ref_sink(g_variant_new_string(s)));
3608 options[OPT_PROTOCOL].values = l;
3609 options[OPT_FRAME_FORMAT].def = g_variant_ref_sink(g_variant_new_string(""));
3611 for (t_idx = INPUT_UNSPEC; t_idx <= INPUT_TEXT; t_idx++) {
3612 s = input_format_texts[t_idx];
3613 l = g_slist_append(l, g_variant_ref_sink(g_variant_new_string(s)));
3615 options[OPT_TEXTINPUT].values = l;
3616 options[OPT_TEXTINPUT].def = g_variant_ref_sink(g_variant_new_string(
3617 input_format_texts[INPUT_UNSPEC]));
3621 SR_PRIV struct sr_input_module input_protocoldata = {
3622 .id = "protocoldata",
3623 .name = "Protocol data",
3624 .desc = "Generate logic traces from protocol's data values",
3625 .exts = (const char *[]){ "sr-protocol", "protocol", "bin", NULL, },
3626 .metadata = { SR_INPUT_META_HEADER | SR_INPUT_META_REQUIRED },
3627 .options = get_options,
3628 .format_match = format_match,