ols: Refactor: Extract trigger setup into private place
[libsigrok.git] / src / hardware / openbench-logic-sniffer / api.c
1 /*
2  * This file is part of the libsigrok project.
3  *
4  * Copyright (C) 2013 Bert Vermeulen <bert@biot.com>
5  *
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.
10  *
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.
15  *
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/>.
18  */
19
20 #include <config.h>
21 #include "protocol.h"
22
23 #define SERIALCOMM "115200/8n1"
24
25 static const uint32_t scanopts[] = {
26         SR_CONF_CONN,
27         SR_CONF_SERIALCOMM,
28 };
29
30 static const uint32_t drvopts[] = {
31         SR_CONF_LOGIC_ANALYZER,
32 };
33
34 static const uint32_t devopts[] = {
35         SR_CONF_LIMIT_SAMPLES | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
36         SR_CONF_SAMPLERATE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
37         SR_CONF_TRIGGER_MATCH | SR_CONF_LIST,
38         SR_CONF_CAPTURE_RATIO | SR_CONF_GET | SR_CONF_SET,
39         SR_CONF_EXTERNAL_CLOCK | SR_CONF_GET | SR_CONF_SET,
40         SR_CONF_CLOCK_EDGE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
41         SR_CONF_PATTERN_MODE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
42         SR_CONF_SWAP | SR_CONF_SET,
43         SR_CONF_RLE | SR_CONF_GET | SR_CONF_SET,
44 };
45
46 static const int32_t trigger_matches[] = {
47         SR_TRIGGER_ZERO,
48         SR_TRIGGER_ONE,
49 };
50
51 static const char* external_clock_edges[] = {
52         "rising", // positive edge
53         "falling" // negative edge
54 };
55
56 #define STR_PATTERN_NONE     "None"
57 #define STR_PATTERN_EXTERNAL "External"
58 #define STR_PATTERN_INTERNAL "Internal"
59
60 /* Supported methods of test pattern outputs */
61 enum {
62         /**
63          * Capture pins 31:16 (unbuffered wing) output a test pattern
64          * that can captured on pins 0:15.
65          */
66         PATTERN_EXTERNAL,
67
68         /** Route test pattern internally to capture buffer. */
69         PATTERN_INTERNAL,
70 };
71
72 static const char *patterns[] = {
73         STR_PATTERN_NONE,
74         STR_PATTERN_EXTERNAL,
75         STR_PATTERN_INTERNAL,
76 };
77
78 /* Channels are numbered 0-31 (on the PCB silkscreen). */
79 SR_PRIV const char *ols_channel_names[] = {
80         "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12",
81         "13", "14", "15", "16", "17", "18", "19", "20", "21", "22", "23",
82         "24", "25", "26", "27", "28", "29", "30", "31",
83 };
84
85 /* Default supported samplerates, can be overridden by device metadata. */
86 static const uint64_t samplerates[] = {
87         SR_HZ(10),
88         SR_MHZ(200),
89         SR_HZ(1),
90 };
91
92 #define RESPONSE_DELAY_US (20 * 1000)
93
94 static GSList *scan(struct sr_dev_driver *di, GSList *options)
95 {
96         struct sr_config *src;
97         struct sr_dev_inst *sdi;
98         struct sr_serial_dev_inst *serial;
99         GSList *l;
100         int num_read;
101         unsigned int i;
102         const char *conn, *serialcomm;
103         char buf[4] = { 0, 0, 0, 0 };
104
105         conn = serialcomm = NULL;
106         for (l = options; l; l = l->next) {
107                 src = l->data;
108                 switch (src->key) {
109                 case SR_CONF_CONN:
110                         conn = g_variant_get_string(src->data, NULL);
111                         break;
112                 case SR_CONF_SERIALCOMM:
113                         serialcomm = g_variant_get_string(src->data, NULL);
114                         break;
115                 }
116         }
117         if (!conn)
118                 return NULL;
119
120         if (!serialcomm)
121                 serialcomm = SERIALCOMM;
122
123         serial = sr_serial_dev_inst_new(conn, serialcomm);
124
125         /* The discovery procedure is like this: first send the Reset
126          * command (0x00) 5 times, since the device could be anywhere
127          * in a 5-byte command. Then send the ID command (0x02).
128          * If the device responds with 4 bytes ("OLS1" or "SLA1"), we
129          * have a match.
130          */
131         sr_info("Probing %s.", conn);
132         if (serial_open(serial, SERIAL_RDWR) != SR_OK)
133                 return NULL;
134
135         if (ols_send_reset(serial) != SR_OK) {
136                 serial_close(serial);
137                 sr_err("Could not use port %s. Quitting.", conn);
138                 return NULL;
139         }
140         send_shortcommand(serial, CMD_ID);
141
142         g_usleep(RESPONSE_DELAY_US);
143
144         if (serial_has_receive_data(serial) == 0) {
145                 sr_dbg("Didn't get any ID reply.");
146                 return NULL;
147         }
148
149         num_read = serial_read_blocking(serial, buf, 4, serial_timeout(serial, 4));
150         if (num_read < 0) {
151                 sr_err("Getting ID reply failed (%d).", num_read);
152                 return NULL;
153         }
154
155         if (strncmp(buf, "1SLO", 4) && strncmp(buf, "1ALS", 4)) {
156                 GString *id = sr_hexdump_new((uint8_t *)buf, num_read);
157
158                 sr_err("Invalid ID reply (got %s).", id->str);
159
160                 sr_hexdump_free(id);
161                 return NULL;
162         }
163
164         /* Definitely using the OLS protocol, check if it supports
165          * the metadata command.
166          */
167         send_shortcommand(serial, CMD_METADATA);
168
169         g_usleep(RESPONSE_DELAY_US);
170
171         if (serial_has_receive_data(serial) != 0) {
172                 /* Got metadata. */
173                 sdi = get_metadata(serial);
174         } else {
175                 /* Not an OLS -- some other board that uses the sump protocol. */
176                 sr_info("Device does not support metadata.");
177                 sdi = g_malloc0(sizeof(struct sr_dev_inst));
178                 sdi->status = SR_ST_INACTIVE;
179                 sdi->vendor = g_strdup("Sump");
180                 sdi->model = g_strdup("Logic Analyzer");
181                 sdi->version = g_strdup("v1.0");
182                 for (i = 0; i < ARRAY_SIZE(ols_channel_names); i++)
183                         sr_channel_new(sdi, i, SR_CHANNEL_LOGIC, TRUE,
184                                         ols_channel_names[i]);
185                 sdi->priv = ols_dev_new();
186         }
187         /* Configure samplerate and divider. */
188         if (ols_set_samplerate(sdi, DEFAULT_SAMPLERATE) != SR_OK)
189                 sr_dbg("Failed to set default samplerate (%"PRIu64").",
190                                 DEFAULT_SAMPLERATE);
191         sdi->inst_type = SR_INST_SERIAL;
192         sdi->conn = serial;
193
194         serial_close(serial);
195
196         return std_scan_complete(di, g_slist_append(NULL, sdi));
197 }
198
199 static int config_get(uint32_t key, GVariant **data,
200         const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
201 {
202         struct dev_context *devc;
203
204         (void)cg;
205
206         if (!sdi)
207                 return SR_ERR_ARG;
208
209         devc = sdi->priv;
210
211         switch (key) {
212         case SR_CONF_SAMPLERATE:
213                 *data = g_variant_new_uint64(devc->cur_samplerate);
214                 break;
215         case SR_CONF_CAPTURE_RATIO:
216                 *data = g_variant_new_uint64(devc->capture_ratio);
217                 break;
218         case SR_CONF_LIMIT_SAMPLES:
219                 *data = g_variant_new_uint64(devc->limit_samples);
220                 break;
221         case SR_CONF_PATTERN_MODE:
222                 if (devc->capture_flags & CAPTURE_FLAG_EXTERNAL_TEST_MODE)
223                         *data = g_variant_new_string(STR_PATTERN_EXTERNAL);
224                 else if (devc->capture_flags & CAPTURE_FLAG_INTERNAL_TEST_MODE)
225                         *data = g_variant_new_string(STR_PATTERN_INTERNAL);
226                 else
227                         *data = g_variant_new_string(STR_PATTERN_NONE);
228                 break;
229         case SR_CONF_RLE:
230                 *data = g_variant_new_boolean(devc->capture_flags & CAPTURE_FLAG_RLE ? TRUE : FALSE);
231                 break;
232         case SR_CONF_EXTERNAL_CLOCK:
233                 *data = g_variant_new_boolean(
234                         devc->capture_flags & CAPTURE_FLAG_CLOCK_EXTERNAL ? TRUE : FALSE);
235                 break;
236         case SR_CONF_CLOCK_EDGE:
237                 *data = g_variant_new_string(external_clock_edges[
238                         devc->capture_flags & CAPTURE_FLAG_INVERT_EXT_CLOCK ? 1 : 0]);
239                 break;
240         default:
241                 return SR_ERR_NA;
242         }
243
244         return SR_OK;
245 }
246
247 static int config_set(uint32_t key, GVariant *data,
248         const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
249 {
250         struct dev_context *devc;
251         uint16_t flag;
252         uint64_t tmp_u64;
253         const char *stropt;
254
255         (void)cg;
256
257         devc = sdi->priv;
258
259         switch (key) {
260         case SR_CONF_SAMPLERATE:
261                 tmp_u64 = g_variant_get_uint64(data);
262                 if (tmp_u64 < samplerates[0] || tmp_u64 > samplerates[1])
263                         return SR_ERR_SAMPLERATE;
264                 return ols_set_samplerate(sdi, g_variant_get_uint64(data));
265         case SR_CONF_LIMIT_SAMPLES:
266                 tmp_u64 = g_variant_get_uint64(data);
267                 if (tmp_u64 < MIN_NUM_SAMPLES)
268                         return SR_ERR;
269                 devc->limit_samples = tmp_u64;
270                 break;
271         case SR_CONF_CAPTURE_RATIO:
272                 devc->capture_ratio = g_variant_get_uint64(data);
273                 break;
274         case SR_CONF_EXTERNAL_CLOCK:
275                 if (g_variant_get_boolean(data)) {
276                         sr_info("Enabling external clock.");
277                         devc->capture_flags |= CAPTURE_FLAG_CLOCK_EXTERNAL;
278                 } else {
279                         sr_info("Disabled external clock.");
280                         devc->capture_flags &= ~CAPTURE_FLAG_CLOCK_EXTERNAL;
281                 }
282                 break;
283         case SR_CONF_CLOCK_EDGE:
284                 stropt = g_variant_get_string(data, NULL);
285                 if (!strcmp(stropt, external_clock_edges[1])) {
286                         sr_info("Triggering on falling edge of external clock.");
287                         devc->capture_flags |= CAPTURE_FLAG_INVERT_EXT_CLOCK;
288                 } else {
289                         sr_info("Triggering on rising edge of external clock.");
290                         devc->capture_flags &= ~CAPTURE_FLAG_INVERT_EXT_CLOCK;
291                 }
292                 break;
293         case SR_CONF_PATTERN_MODE:
294                 stropt = g_variant_get_string(data, NULL);
295                 if (!strcmp(stropt, STR_PATTERN_NONE)) {
296                         sr_info("Disabling test modes.");
297                         flag = 0x0000;
298                 } else if (!strcmp(stropt, STR_PATTERN_INTERNAL)) {
299                         sr_info("Enabling internal test mode.");
300                         flag = CAPTURE_FLAG_INTERNAL_TEST_MODE;
301                 } else if (!strcmp(stropt, STR_PATTERN_EXTERNAL)) {
302                         sr_info("Enabling external test mode.");
303                         flag = CAPTURE_FLAG_EXTERNAL_TEST_MODE;
304                 } else {
305                         return SR_ERR;
306                 }
307                 devc->capture_flags &= ~CAPTURE_FLAG_INTERNAL_TEST_MODE;
308                 devc->capture_flags &= ~CAPTURE_FLAG_EXTERNAL_TEST_MODE;
309                 devc->capture_flags |= flag;
310                 break;
311         case SR_CONF_SWAP:
312                 if (g_variant_get_boolean(data)) {
313                         sr_info("Enabling channel swapping.");
314                         devc->capture_flags |= CAPTURE_FLAG_SWAP_CHANNELS;
315                 } else {
316                         sr_info("Disabling channel swapping.");
317                         devc->capture_flags &= ~CAPTURE_FLAG_SWAP_CHANNELS;
318                 }
319                 break;
320         case SR_CONF_RLE:
321                 if (g_variant_get_boolean(data)) {
322                         sr_info("Enabling RLE.");
323                         devc->capture_flags |= CAPTURE_FLAG_RLE;
324                 } else {
325                         sr_info("Disabling RLE.");
326                         devc->capture_flags &= ~CAPTURE_FLAG_RLE;
327                 }
328                 break;
329         default:
330                 return SR_ERR_NA;
331         }
332
333         return SR_OK;
334 }
335
336 static int config_list(uint32_t key, GVariant **data,
337         const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
338 {
339         struct dev_context *devc;
340         int num_ols_changrp, i;
341
342         switch (key) {
343         case SR_CONF_SCAN_OPTIONS:
344         case SR_CONF_DEVICE_OPTIONS:
345                 return STD_CONFIG_LIST(key, data, sdi, cg, scanopts, drvopts, devopts);
346         case SR_CONF_SAMPLERATE:
347                 *data = std_gvar_samplerates_steps(ARRAY_AND_SIZE(samplerates));
348                 break;
349         case SR_CONF_TRIGGER_MATCH:
350                 *data = std_gvar_array_i32(ARRAY_AND_SIZE(trigger_matches));
351                 break;
352         case SR_CONF_CLOCK_EDGE:
353                 *data = std_gvar_array_str(ARRAY_AND_SIZE(external_clock_edges));
354                 break;
355         case SR_CONF_PATTERN_MODE:
356                 *data = g_variant_new_strv(ARRAY_AND_SIZE(patterns));
357                 break;
358         case SR_CONF_LIMIT_SAMPLES:
359                 if (!sdi)
360                         return SR_ERR_ARG;
361                 devc = sdi->priv;
362                 if (devc->capture_flags & CAPTURE_FLAG_RLE)
363                         return SR_ERR_NA;
364                 if (devc->max_samples == 0)
365                         /* Device didn't specify sample memory size in metadata. */
366                         return SR_ERR_NA;
367                 /*
368                  * Channel groups are turned off if no channels in that group are
369                  * enabled, making more room for samples for the enabled group.
370                 */
371                 uint32_t channel_mask = ols_channel_mask(sdi);
372                 num_ols_changrp = 0;
373                 for (i = 0; i < 4; i++) {
374                         if (channel_mask & (0xff << (i * 8)))
375                                 num_ols_changrp++;
376                 }
377
378                 *data = std_gvar_tuple_u64(MIN_NUM_SAMPLES,
379                         (num_ols_changrp) ? devc->max_samples / num_ols_changrp : MIN_NUM_SAMPLES);
380                 break;
381         default:
382                 return SR_ERR_NA;
383         }
384
385         return SR_OK;
386 }
387
388 static int dev_acquisition_start(const struct sr_dev_inst *sdi)
389 {
390         int ret;
391         struct dev_context *devc;
392         struct sr_serial_dev_inst *serial;
393
394         devc = sdi->priv;
395         serial = sdi->conn;
396
397         ret = ols_prepare_acquisition(sdi);
398         if (ret != SR_OK)
399                 return ret;
400
401         /* Start acquisition on the device. */
402         if (send_shortcommand(serial, CMD_ARM_BASIC_TRIGGER) != SR_OK)
403                 return SR_ERR;
404
405         /* Reset all operational states. */
406         devc->rle_count = devc->num_transfers = 0;
407         devc->num_samples = devc->num_bytes = 0;
408         devc->cnt_bytes = devc->cnt_samples = devc->cnt_samples_rle = 0;
409         memset(devc->sample, 0, 4);
410
411         std_session_send_df_header(sdi);
412
413         /* If the device stops sending for longer than it takes to send a byte,
414          * that means it's finished. But wait at least 100 ms to be safe.
415          */
416         serial_source_add(sdi->session, serial, G_IO_IN, 100,
417                         ols_receive_data, (struct sr_dev_inst *)sdi);
418
419         return SR_OK;
420 }
421
422 static int dev_acquisition_stop(struct sr_dev_inst *sdi)
423 {
424         abort_acquisition(sdi);
425
426         return SR_OK;
427 }
428
429 static struct sr_dev_driver ols_driver_info = {
430         .name = "ols",
431         .longname = "Openbench Logic Sniffer & SUMP compatibles",
432         .api_version = 1,
433         .init = std_init,
434         .cleanup = std_cleanup,
435         .scan = scan,
436         .dev_list = std_dev_list,
437         .dev_clear = std_dev_clear,
438         .config_get = config_get,
439         .config_set = config_set,
440         .config_list = config_list,
441         .dev_open = std_serial_dev_open,
442         .dev_close = std_serial_dev_close,
443         .dev_acquisition_start = dev_acquisition_start,
444         .dev_acquisition_stop = dev_acquisition_stop,
445         .context = NULL,
446 };
447 SR_REGISTER_DEV_DRIVER(ols_driver_info);